K-means算法Java实现

public class KMeansCluster { 

        private int k;//簇的个数 

        private int num = 100000;//迭代次数 

        private List<double> datas;//原始样本集 

        private String address;//样本集路径 

        private List<point> data = new ArrayList<point>(); 

        private AbstractDistance distance = new AbstractDistance() { 

            @Override 

            public double getDis(Point p1, Point p2) { 

                //欧几里德距离 

                return Math.sqrt(Math.pow(p1.getX() - p2.getX(), 2) + Math.pow(p1.getY() - p2.getY(), 2)); 

            } 

        }; 

       

        public KMeansCluster(int k, int num, String address) { 

            this.k = k; 

            this.num = num; 

            this.address = address; 

        } 

       

        public KMeansCluster(int k, String address) { 

            this.k = k; 

            this.address = address; 

        } 

       

        public KMeansCluster(int k, List<double> datas) { 

            this.k = k; 

            this.datas = datas; 

        } 

       

        public KMeansCluster(int k, int num, List<double> datas) { 

            this.k = k; 

            this.num = num; 

            this.datas = datas; 

        } 

       

        private void check() { 

            if (k == 0) 

                throw new IllegalArgumentException("k must be the number > 0"); 

       

            if (address == null && datas == null) 

                throw new IllegalArgumentException("program can't get real data"); 

        } 

       

        /**

         * 初始化数据

         *

         * @throws java.io.FileNotFoundException

         */ 

        public void init() throws FileNotFoundException { 

            check(); 

            //读取文件，init data 

            //处理原始数据 

            for (int i = 0, j = datas.size(); i < j; i++) 

                data.add(new Point(i, datas.get(i), 0)); 

        } 

       

        /**

         * 第一次随机选取中心点

         *

         * @return

         */ 

        public Set<point> chooseCenter() { 

            Set<point> center = new HashSet<point>(); 

            Random ran = new Random(); 

            int roll = 0; 

            while (center.size() < k) { 

                roll = ran.nextInt(data.size()); 

                center.add(data.get(roll)); 

            } 

            return center; 

        } 

       

        /**

         * @param center

         * @return

         */ 

        public List<cluster> prepare(Set<point> center) { 

            List<cluster> cluster = new ArrayList<cluster>(); 

            Iterator<point> it = center.iterator(); 

            int id = 0; 

            while (it.hasNext()) { 

                Point p = it.next(); 

                if (p.isBeyond()) { 

                    Cluster c = new Cluster(id++, p); 

                    c.addPoint(p); 

                    cluster.add(c); 

                } else 

                    cluster.add(new Cluster(id++, p)); 

            } 

            return cluster; 

        } 

       

        /**

         * 第一次运算，中心点为样本值

         *

         * @param center

         * @param cluster

         * @return

         */ 

        public List<cluster> clustering(Set<point> center, List<cluster> cluster) { 

            Point[] p = center.toArray(new Point[0]); 

            TreeSet<distence> distence = new TreeSet<distence>();//存放距离信息 

            Point source; 

            Point dest; 

            boolean flag = false; 

            for (int i = 0, n = data.size(); i < n; i++) { 

                distence.clear(); 

                for (int j = 0; j < center.size(); j++) { 

                    if (center.contains(data.get(i))) 

                        break; 

       

                    flag = true; 

                    // 计算距离 

                    source = data.get(i); 

                    dest = p[j]; 

                    distence.add(new Distence(source, dest, distance)); 

                } 

                if (flag == true) { 

                    Distence min = distence.first(); 

                    for (int m = 0, k = cluster.size(); m < k; m++) { 

                        if (cluster.get(m).getCenter().equals(min.getDest())) 

                            cluster.get(m).addPoint(min.getSource()); 

       

                    } 

                } 

                flag = false; 

            } 

       

            return cluster; 

        } 

       

        /**

         * 迭代运算，中心点为簇内样本均值

         *

         * @param cluster

         * @return

         */ 

        public List<cluster> cluster(List<cluster> cluster) { 

    //        double error; 

            Set<point> lastCenter = new HashSet<point>(); 

            for (int m = 0; m < num; m++) { 

    //            error = 0; 

                Set<point> center = new HashSet<point>(); 

                // 重新计算聚类中心 

                for (int j = 0; j < k; j++) { 

                    List<point> ps = cluster.get(j).getMembers(); 

                    int size = ps.size(); 

                    if (size < 3) { 

                        center.add(cluster.get(j).getCenter()); 

                        continue; 

                    } 

                    // 计算距离 

                    double x = 0.0, y = 0.0; 

                    for (int k1 = 0; k1 < size; k1++) { 

                        x += ps.get(k1).getX(); 

                        y += ps.get(k1).getY(); 

                    } 

                    //得到新的中心点 

                    Point nc = new Point(-1, x / size, y / size, false); 

                    center.add(nc); 

                } 

                if (lastCenter.containsAll(center))//中心点不在变化，退出迭代 

                    break; 

                lastCenter = center; 

                // 迭代运算 

                cluster = clustering(center, prepare(center)); 

    //            for (int nz = 0; nz < k; nz++) { 

    //                error += cluster.get(nz).getError();//计算误差 

    //            } 

            } 

            return cluster; 

        } 

       

        /**

         * 输出聚类信息到控制台

         *

         * @param cs

         */ 

        public void out2console(List<cluster> cs) { 

            for (int i = 0; i < cs.size(); i++) { 

                System.out.println("No." + (i + 1) + " cluster:"); 

                Cluster c = cs.get(i); 

                List<point> p = c.getMembers(); 

                for (int j = 0; j < p.size(); j++) { 

                    System.out.println("\t" + p.get(j).getX() + " "); 

                } 

                System.out.println(); 

            } 

        } 

    }