spark 聚类java实现 如何和前台对接

spark 聚类java实现 如何和前台对接

以前做项目时候写的代码，数据是一维的，多维的也一样，把距离计算的改一改就行int term = Math.abs(dotlist.get(centerIndex[j]).x- dotlist.get(i).x);


[java] view plaincopy
package uestc.dmlab.call;  

import java.io.BufferedReader;  
import java.io.FileReader;  
import java.security.KeyStore.Entry;  
import java.util.HashMap;  
import java.util.HashSet;  
import java.util.Iterator;  
import java.util.LinkedList;  
import java.util.List;  
import java.util.Map;  
import java.util.Random;  
import java.util.Set;  

public class Clustering {  

      
    public static HashMap cluster(String fileName, int k,  
            int minDistance) {  
        try {  
            BufferedReader br = new BufferedReader(new FileReader(fileName));  
            List dotlist = new LinkedList();  
            String line;  
            int count = 0;// 行数  
            while ((line = br.readLine()) != null) {  
                String s[] = line.split(",");  
                Dot dot = new Dot();  
                dot.isCenter = false;  
                dot.isVirtual = false;  
                dot.name = s[0];  
                // if(s.length<4){  
                // System.out.println(line);  
                // }  
                dot.x = Integer.parseInt(s[3]);  
                dotlist.add(dot);  
                count++;  
            }  
            if (count < k) {  
                k = count;  
            }  

            // 随机初始化k个聚类中心  
            int centerIndex[] = new int[k]; // 存储k个中心点在dotlist中的索引  
            int centerNum = k;  
            while (centerNum > 0) {  
                int index = new Random().nextInt(count);  
                if (!dotlist.get(index).isCenter) {  
                    centerNum--;  
                    dotlist.get(index).isCenter = true;  
                    centerIndex[centerNum] = index;  
                }  
            }  

            // K个聚类  
            Cluster[] clusers = new Cluster[k];  

            boolean flag = true;  
            while (flag) {  
                flag = false;  
                clusers = new Cluster[k];  
                for (int i = 0; i < clusers.length; i++) {  
                    clusers[i] = new Cluster();  
                }  
                //System.out.println(clusers.length);  
                // 找到离第i个点最近的聚类中心  
                for (int i = 0; i < dotlist.size(); i++) {  
                    // 该点不是中心点也不是虚拟点就计算它与所有中心点的距离并取最小值  
                    // if(!dotlist.get(i).isCenter&&!dotlist.get(i).isVirtual){  
                    if (!dotlist.get(i).isVirtual) {  
                        int distance = Integer.MAX_VALUE;  
                        int c = 0;// 记录离该节点最近的中心点的索引  
                        for (int j = 0; j < k; j++) {  
                            int term = Math.abs(dotlist.get(centerIndex[j]).x  
                                    - dotlist.get(i).x);  
                            if (distance > term) {  
                                distance = term;  
                                c = j;  
                            }  
                        }  
                        clusers[c].dots.add(i);  
                    }  
                }  

                // 重新计算聚类中心  
                for (int i = 0; i < k; i++) {  
                    Cluster cluster = clusers[i];  

                    if (cluster.dots.size() > 0) { //若该类中有点  
                        int sum = 0;  
                        for (int j = 0; j < cluster.dots.size(); j++) {  
                            sum += dotlist.get(cluster.dots.get(j)).x;  
                        }  

                        Dot dot = new Dot();  
                        dot.x = sum / cluster.dots.size();  
                        dot.isCenter = true;  
                        dot.isVirtual = true;  

                        // 新旧聚类中心的距离  
                        int term = Math.abs(dotlist.get(centerIndex[i]).x  
                                - dot.x);  
                        if (term > minDistance)  
                            flag = true;  

                        dotlist.add(dot);  
                        centerIndex[i] = dotlist.indexOf(dot); // 第i个聚类的中心改变  
                    }  
                }  
            }  

            // 生成分类映射  
            HashMap map = new HashMap();  
            for (Dot dot : dotlist) {  
                if (dot.isVirtual == false) {  
                    int className = -1;  
                    for (int i = 0; i < k; i++) {  
                        if (clusers[i].dots.contains(dotlist.indexOf(dot)))  
                            className = i;  
                    }  
                    map.put(dot.name, className);  
                }  
            }  
            return map;  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
        return new HashMap();  

    }  

    public static void main(String[] args) {  
        Map map = Clustering.cluster(  
                "C:/Documents and Settings/Administrator/桌面/123.txt", 2, 0);  
        Iterator> it = map.entrySet().iterator();  
        while(it.hasNext()){  
            Map.Entry entry = it.next();  
            System.out.println(entry.getKey()+","+entry.getValue());  
        }  

    }  
}  

class Dot {  
    String name;  
    int x;  
    boolean isCenter;  
    boolean isVirtual;  
}  

class Cluster {  
    // 记录了该类中点的索引值  
    LinkedList dots = new LinkedList();

搜一下：spark 聚类java实现 如何和前台对接