java KNN算法

由于看网上的java有点多，自己写了一份，本人也是初学者，有错误请提出，大家一起学习。

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.*;


public class Index {
    public static void main(String[] args){
        List<List<Double>> Filedatas = new ArrayList<List<Double>>();
        List<List<Double>> Testdatas = new ArrayList<List<Double>>();
        
        readFile(Filedatas,Testdatas);
        KNN knn = new KNN();
        
        for(int i=0;i<Filedatas.size();i++){
            String s = knn.comdistance(3,Filedatas,Testdatas.get(i));
            print(s,Testdatas.get(i));
        }
    }
    //第4步、打印出结果
    private static void print(String s,List<Double> testdata) {
        System.out.print("测试数据：");
        for(int i=0;i<testdata.size();i++){
            System.out.print(testdata.get(i) + " ");
        }
        int label = Math.round(Float.parseFloat(s));
        System.out.println("所属类别：" + label);
    }

    //第1.1步、读取文件
    private static void readFile(List<List<Double>> Filedatas, List<List<Double>> Testdatas) {
        try {
            BufferedReader bfd = new BufferedReader(new FileReader(new File("D://a.txt")));
            Filedatas = read(bfd,Filedatas);
            BufferedReader bft = new BufferedReader(new FileReader(new File("D://b.txt")));
            Testdatas = read(bft,Testdatas);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }        
    }

    //第1.2步、读取文件
    private static List<List<Double>> read(BufferedReader bf, List<List<Double>> datas) {
        try {
            String str = bf.readLine();
            while(str != null){
                List<Double> d = new ArrayList<Double>();
                String[] string = str.split(" "); 
                for (String s : string) {
                    d.add(Double.parseDouble(s));
                }
                datas.add(d);
                str = bf.readLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return datas;
    }

    
}

import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.PriorityQueue;

public class KNN {
    
    public String comdistance(int k, List<List<Double>> filedatas,List<Double> testdata) {
        //第2.1步、对加入queue队列的项进行距离的排序
        PriorityQueue<KNNNode> pq = new PriorityQueue<KNNNode>(k,new Comparator<KNNNode>() {    //优先级队列，按照distance的大小进行排列
            @Override
            public int compare(KNNNode o1, KNNNode o2) {
                if(o1.getDistance() >= o2.getDistance()){
                    return -1;
                }
                else{
                    return 1;
                }
            }
        });
        //第2.2步、计算测试点与训练点的距离，并add进队列，挑出与测试点距离最近的K个点
        for(int i=0;i<k;i++){
            double distance = 0;
            for(int j=0;j<filedatas.get(i).size()-1;j++){
                distance += (filedatas.get(i).get(j) - testdata.get(j)) * (filedatas.get(i).get(j) - testdata.get(j));
            }
            KNNNode node = new KNNNode(filedatas.get(i).get(filedatas.get(i).size()-1).toString(),distance);
            pq.add(node);
        }
        for(int i=k;i<filedatas.size();i++){
            double distance = 0;
            for(int j=0;j<filedatas.get(i).size()-1;j++){
                distance += (filedatas.get(i).get(j) - testdata.get(j)) * (filedatas.get(i).get(j) - testdata.get(j));
            }
            KNNNode node = new KNNNode(filedatas.get(i).get(filedatas.get(i).size()-1).toString(),distance);
            if(pq.peek().getDistance() >= distance ){
                pq.remove();
                pq.add(node);
            }
        }
        String s = decide(pq);
        return s;
    }
    //第3步、把选择好的最近的K个点的类别进行比较，多的即是测试点的类别
    private String decide(PriorityQueue<KNNNode> pq) {
        Map<String,Integer> m = new HashMap<String,Integer>();
        for (KNNNode Node : pq) {
            if(m.containsKey(Node.getC())){
                m.put(Node.getC(), m.get(Node.getC()) + 1);
            }
            else{
                m.put(Node.getC(), 1);
            }
        }
        Object[] o = m.keySet().toArray();

        if(o.length == 1){
            return o[0].toString();
        }
        else{
            for(int i=0;i<o.length;i++){
                for(int j=i;j<o.length;j++){
                    if(i != j){
                        if(m.get(o[i]) > m.get(o[j])){
                            return o[i].toString();
                        }
                        else{
                            return o[j].toString();
                        }
                    }
                }
            }
        }
        return null;
    }
}

public class KNNNode {
    
    private String c;
    private double distance;
    
    public KNNNode(String c, double distance) {
        super();
        this.c = c;
        this.distance = distance;
    }
    
    public String getC() {
        return c;
    }
    public double getDistance() {
        return distance;
    }
    public void setC(String c) {
        this.c = c;
    }
    public void setDistance(double distance) {
        this.distance = distance;
    }
}

训练数据:

1.0 1.1 1.2 2.1 0.3 2.3 1.4 0.5 1
1.7 1.2 1.4 2.0 0.2 2.5 1.2 0.8 1
1.2 1.8 1.6 2.5 0.1 2.2 1.8 0.2 1
1.9 2.1 6.2 1.1 0.9 3.3 2.4 5.5 0
1.0 0.8 1.6 2.1 0.2 2.3 1.6 0.5 1
1.6 2.1 5.2 1.1 0.8 3.6 2.4 4.5 0

测试数据：

1.0 1.1 1.2 2.1 0.3 2.3 1.4 0.5
1.7 1.2 1.4 2.0 0.2 2.5 1.2 0.8
1.2 1.8 1.6 2.5 0.1 2.2 1.8 0.2
1.9 2.1 6.2 1.1 0.9 3.3 2.4 5.5
1.0 0.8 1.6 2.1 0.2 2.3 1.6 0.5
1.6 2.1 5.2 1.1 0.8 3.6 2.4 4.5