kmeans算法java代码

kmeans算法java代码
Kmeans算法是一种常见的聚类算法，可以将数据集划分为几个不同的簇。

在这篇文章中，我们将分享Kmeans算法的Java代码实现。

首先，我们需要定义一个Kmeans类，并在其构造函数中指定簇的数量和数据集。

接着，我们需要实现一个fit方法，该方法将执行Kmeans算法的主要逻辑。

在fit方法中，我们首先需要为每个簇随机初始化一个中心点。

然后，我们将每个数据点分配给距离最近的中心点所在的簇。

接着，我们需要重新计算每个簇的中心点，并在下一次迭代中使用这些中心点。

我们重复这个过程，直到中心点不再改变或达到迭代次数的上限。

以下是Kmeans类的Java代码实现：
```java
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
public class Kmeans {
private int k;
private List<double[]> data;
private List<List<double[]>> clusters;
public Kmeans(int k, List<double[]> data) {
this.k = k;
this.data = data;
this.clusters = new ArrayList<>();
}
public void fit(int maxIterations) {
// Randomly initialize cluster centers
List<double[]> centers = new ArrayList<>();
Random random = new Random();
for (int i = 0; i < k; i++) {
int index = random.nextInt(data.size());
double[] center = data.get(index).clone();
centers.add(center);
List<double[]> cluster = new ArrayList<>();
cluster.add(center);
clusters.add(cluster);
}
// Repeat until convergence or max iterations reached boolean converged = false;
int iteration = 0;
while (!converged && iteration < maxIterations) {
// Assign each data point to closest center
for (double[] point : data) {
double minDistance = Double.MAX_VALUE;
int closestCluster = -1;
for (int i = 0; i < k; i++) {
double[] center = centers.get(i);
double distance = euclideanDistance(point, center); if (distance < minDistance) {
minDistance = distance;
closestCluster = i;
}
}
clusters.get(closestCluster).add(point.clone());
}
// Update cluster centers
converged = true;
for (int i = 0; i < k; i++) {
List<double[]> cluster = clusters.get(i);
if (cluster.size() > 1) {
double[] newCenter = calculateCenter(cluster);
if (!arrayEquals(newCenter, centers.get(i))) {
centers.set(i, newCenter);
clusters.set(i, new ArrayList<>());
clusters.get(i).add(newCenter);
converged = false;
}
}
}
iteration++;
}
}
private double euclideanDistance(double[] a, double[] b) {
double sum = 0;
for (int i = 0; i < a.length; i++) {
double diff = a[i] - b[i];
sum += diff * diff;
}
return Math.sqrt(sum);
}
private double[] calculateCenter(List<double[]> cluster) {
double[] sum = new double[cluster.get(0).length];
for (double[] point : cluster) {
for (int i = 0; i < point.length; i++) {
sum[i] += point[i];
}
}
for (int i = 0; i < sum.length; i++) {
sum[i] /= cluster.size();
}
return sum;
}
private boolean arrayEquals(double[] a, double[] b) { if (a.length != b.length) {
return false;
}
for (int i = 0; i < a.length; i++) {
if (a[i] != b[i]) {
return false;
}
}
return true;
}
public List<List<double[]>> getClusters() {
return clusters;
}
}
```
上面的代码实现了Kmeans算法的核心逻辑。

我们可以通过以下
代码来测试我们的Kmeans类：
```java
public static void main(String[] args) {
// Generate sample data
List<double[]> data = new ArrayList<>();
Random random = new Random();
for (int i = 0; i < 100; i++) {
double x = random.nextDouble() * 10;
double y = random.nextDouble() * 10;
double[] point = {x, y};
data.add(point);
}
// Cluster data
int k = 3;
Kmeans kmeans = new Kmeans(k, data);
kmeans.fit(1000);
List<List<double[]>> clusters = kmeans.getClusters(); // Print results
for (int i = 0; i < k; i++) {
System.out.println('Cluster ' + i + ':');
for (double[] point : clusters.get(i)) {
System.out.println(Arrays.toString(point));
}
}
}
```
在上面的代码中，我们生成了一个包含100个随机二维点的数据集，然后使用Kmeans算法将其聚类为3个簇。

最后，我们将结果打印到控制台上。

希望这篇文章能够帮助您实现自己的Kmeans算法，或者将其应用于您的项目中。