java实现k-means聚类算法

K-means聚类算法是一种常用的无监督学习算法，可以将数据集划分为K个不同的类别，每个类别由其质心表示。Java实现K-means聚类算法的步骤如下：

1. 随机选择K个数据点作为初始质心，可以使用java.util.Random类实现随机选择。

2. 根据初始质心，将数据点分配到最近的质心所在的类别中。可以使用欧几里得距离或曼哈顿距离等方式计算数据点到各个质心的距离，然后将数据点分配到距离最近的质心所在的类别中。

3. 计算每个类别的质心，即所有数据点的坐标平均值。可以使用java.util.stream包中的方法对数据点进行求和和计数，然后计算坐标平均值。

4. 重复第2步和第3步，直到质心不再改变或达到最大迭代次数。

下面是Java代码实现K-means聚类算法的示例：

import java.util.*;

public class KMeans {
    private List<Point> data; // 数据集
    private int k; // 类别数
    private List<Point> centers; // 质心集合

    public KMeans(List<Point> data, int k) {
        this.data = data;
        this.k = k;
        centers = new ArrayList<>();
    }

    // 初始化质心
    private void initCenters() {
        Random random = new Random();
        for (int i = 0; i < k; i++) {
            Point center = data.get(random.nextInt(data.size()));
            centers.add(center);
        }
    }

    // 分配数据点到最近的质心所在的类别中
    private void assignPoints() {
        for (Point point : data) {
            double minDistance = Double.MAX_VALUE;
            int minIndex = 0;
            for (int i = 0; i < k; i++) {
                double distance = point.distance(centers.get(i));
                if (distance < minDistance) {
                    minDistance = distance;
                    minIndex = i;
                }
            }
            point.setCluster(minIndex);
        }
    }

    // 计算每个类别的质心
    private void computeCenters() {
        for (int i = 0; i < k; i++) {
            List<Point> points = new ArrayList<>();
            for (Point point : data) {
                if (point.getCluster() == i) {
                    points.add(point);
                }
            }
            Point center = Point.mean(points);
            centers.set(i, center);
        }
    }

    // 聚类
    public void cluster() {
        initCenters();
        int maxIter = 100;
        int iter = 0;
        double epsilon = 0.001;
        double prevCost = Double.MAX_VALUE;
        while (iter < maxIter) {
            assignPoints();
            computeCenters();
            double cost = cost();
            if (Math.abs(cost - prevCost) < epsilon) {
                break;
            }
            prevCost = cost;
            iter++;
        }
    }

    // 计算聚类代价
    private double cost() {
        double cost = 0;
        for (Point point : data) {
            Point center = centers.get(point.getCluster());
            cost += point.distance(center);
        }
        return cost;
    }
}

其中，Point类表示一个数据点，包含x、y坐标和所属的类别；mean方法表示计算一组数据点的坐标平均值。可以根据具体应用场景修改代码实现。