kmeans聚类算法代码java

以下是一个简单的K-means聚类算法的Java实现示例：

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class KMeans {

    static class Point {
        double x, y;

        Point(double x, double y) {
            this.x = x;
            this.y = y;
        }

        double distance(Point p) {
            return Math.sqrt((x - p.x) * (x - p.x) + (y - p.y) * (y - p.y));
        }
    }

    static class Cluster {
        Point center;
        List<Point> points;

        Cluster(Point center) {
            this.center = center;
            this.points = new ArrayList<>();
        }

        void updateCenter() {
            double sumX = 0, sumY = 0;
            for (Point p : points) {
                sumX += p.x;
                sumY += p.y;
            }
            center.x = sumX / points.size();
            center.y = sumY / points.size();
        }
    }

    public static void main(String[] args) {
        // 生成随机数据点
        List<Point> points = generateRandomPoints(100, 0, 100);

        // 初始化聚类中心
        List<Cluster> clusters = initializeClusters(3, points);

        // 迭代聚类
        for (int i = 0; i < 10; i++) {
            assignPointsToClusters(clusters, points);
            updateClusterCenters(clusters);
        }

        // 输出聚类结果
        for (int i = 0; i < clusters.size(); i++) {
            System.out.println("Cluster " + i + ":");
            for (Point p : clusters.get(i).points) {
                System.out.println("(" + p.x + ", " + p.y + ")");
            }
            System.out.println();
        }
    }

    static List<Point> generateRandomPoints(int num, double min, double max) {
        List<Point> points = new ArrayList<>();
        Random rand = new Random();
        for (int i = 0; i < num; i++) {
            double x = min + (max - min) * rand.nextDouble();
            double y = min + (max - min) * rand.nextDouble();
            points.add(new Point(x, y));
        }
        return points;
    }

    static List<Cluster> initializeClusters(int k, List<Point> points) {
        List<Cluster> clusters = new ArrayList<>();
        Random rand = new Random();
        for (int i = 0; i < k; i++) {
            Point center = points.get(rand.nextInt(points.size()));
            clusters.add(new Cluster(center));
        }
        return clusters;
    }

    static void assignPointsToClusters(List<Cluster> clusters, List<Point> points) {
        for (Cluster cluster : clusters) {
            cluster.points.clear();
        }
        for (Point p : points) {
            Cluster closest = null;
            double minDist = Double.MAX_VALUE;
            for (Cluster cluster : clusters) {
                double dist = p.distance(cluster.center);
                if (dist < minDist) {
                    minDist = dist;
                    closest = cluster;
                }
            }
            closest.points.add(p);
        }
    }

    static void updateClusterCenters(List<Cluster> clusters) {
        for (Cluster cluster : clusters) {
            cluster.updateCenter();
        }
    }
}

这个Java程序实现了K-means聚类算法，主要包含以下几个步骤：

1. 数据生成：生成随机数据点。
2. 初始化聚类中心：随机选择k个点作为初始聚类中心。
3. 迭代聚类：重复以下步骤直到收敛：
- 将每个点分配到最近的聚类中心。
- 更新每个聚类的中心点。
4. 输出结果：打印每个聚类的点。

该程序使用了简单的欧几里得距离来计算点与聚类中心之间的距离，并假设数据为二维点。你可以根据需要修改数据生成和距离计算的方法，以适应不同的数据类型和维度。