java 朴素贝叶斯

由于在网上找的bayes的源码都是基于应用的，本人才疏学浅，看不太懂，自己花了2天时间写了个粗糙的代码（基于李航那本书的例子），由于只是初学，若有错误，请指出，大家一起学习！

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Bayes {
    public static void main(String[] args){
        List<List<String>> filelist = new ArrayList<List<String>>();
        Map<String,Double> prioriP = new HashMap<String,Double>();
        Map<String,Integer> prioriNo = new HashMap<String,Integer>();
        Map<String,Double> result = new HashMap<String,Double>();
        String s1 = "D://1.txt";
        String s2 = "D://2.txt";
        filelist = read(filelist,s1);
        prioriP = computepirior(filelist,prioriP,prioriNo);
        List<List<String>> testlist = new ArrayList<List<String>>();
        testlist = read(testlist,s2);
        result = decide(prioriP,filelist,testlist,prioriNo);
        print(result,testlist);
    }
    //第4步、打印结构
    private static void print(Map<String, Double> result,List<List<String>> testlist) {
        System.out.print("测试数据:" + "   ");
        for(int i=0;i<testlist.size();i++){
            System.out.print("特征" + (i+1) +" :");
            for(int j=0;j<testlist.get(i).size();j++){
                System.out.print(testlist.get(i).get(j) + "   ");
            }
        }
        System.out.print("所属类别：" + result.keySet().iterator().next());
    }
    //第3.1步、把元数据根据所属类别分开处理
    private static Map<String, Double> decide(Map<String, Double> prioriP, List<List<String>> filelist, List<List<String>> testlist, Map<String, Integer> prioriNo) {
        List<Map<String,Integer>> map = new ArrayList<Map<String,Integer>>();
        List<List<List<String>>> fc = new ArrayList<List<List<String>>>();
        
        for(Map.Entry<String, Integer> entry : prioriNo.entrySet()){
            List<List<String>> filecopy = new ArrayList<List<String>>();
            for(int i=0;i<filelist.size();i++){
                List<String> list = new ArrayList<String>();
                for(int j=0;j<filelist.get(i).size();j++){
                    if(filelist.get(filelist.size()-1).get(j).equals(entry.getKey())){
                        list.add(filelist.get(i).get(j));
                    }
                }
                filecopy.add(list);
            }
            fc.add(filecopy);
        }

        //有几组测试数据，本来想实现的是测试数据是多对，自己写不出来，这段代码有待改进
        //第3.2步、测试数据在条件下出现的次数
        List<Map<String,Integer>> l = new ArrayList<Map<String,Integer>>();
        for(int i=0;i<fc.size();i++){
            Map<String,Integer> mapdecide = new HashMap<String,Integer>();
            for(int k=0;k<fc.get(i).size()-1;k++){
                for(int j=0;j<fc.get(i).get(k).size();j++){                                //需要和元数据比较的次数
                    if(testlist.get(k).get(0).equals(fc.get(i).get(k).get(j))){
                        if(mapdecide.containsKey(testlist.get(k).get(0))){
                            mapdecide.put(testlist.get(k).get(0), mapdecide.get(testlist.get(k).get(0)) + 1);
                        }
                        else{
                            mapdecide.put(testlist.get(k).get(0), 1);
                        }
                    }
                }
            }
            l.add(mapdecide);
        }
        
        //第3.3步、求后验概率，并比较哪个类别的概率大即所属类别
        Map<String,Double> m = new HashMap<String,Double>();
        for(int i=0;i<l.size();i++){
            double d = 1.0;
            for(Map.Entry<String, Integer> entry : l.get(i).entrySet()){
                d *= (entry.getValue()/(double)fc.get(i).get(fc.get(i).size()-1).size());
            }
            m.put(fc.get(i).get(fc.get(i).size()-1).get(0), prioriP.get(fc.get(i).get(fc.get(i).size()-1).get(0)) * d);
        }
        
        Double max = 0.0;
        for(Map.Entry<String, Double> e : m.entrySet()){
            if(max <= e.getValue()){
                max = e.getValue();
            }
        }
        
        Map<String,Double> result = new HashMap<String,Double>();
        for(Map.Entry<String, Double> e:m.entrySet()){
            if(max == e.getValue()){
                result.put(e.getKey(), e.getValue());
            }
        }
        return result;
    }
    
    //第2步、求先验概率
    private static Map<String, Double> computepirior(List<List<String>> list, Map<String, Double> prioriP, Map<String, Integer> m) {
        
        for(int i=0;i<list.get(list.size()-1).size();i++){
            if(m.containsKey(list.get(list.size()-1).get(i))){
                m.put(list.get(list.size()-1).get(i),m.get(list.get(list.size()-1).get(i)) + 1);
            }
            else{
                m.put(list.get(list.size()-1).get(i),1);
            }
        }
        for (Map.Entry<String,Integer> entry : m.entrySet()) {
            prioriP.put(entry.getKey(),(entry.getValue()/(double)list.get(list.size()-1).size()));
        }
        return prioriP;
    }
    //第1步、读取测试数据和训练数据
    private static List<List<String>> read(List<List<String>> list, String sread) {
        try {
            FileReader fr = new FileReader(new File(sread));
            BufferedReader br = new BufferedReader(fr);
            String string = br.readLine();
            while(string != null){
                List<String> l = new ArrayList<String>();
                String[] str = string.split(" ");
                for (String s : str) {
                    l.add(s);
                }
                list.add(l);
                string = br.readLine();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return list;
    }
}

 训练数据：

1 1 1 1 1 2 2 2 2 2 3 3 3 3 3
S M M S S S M M L L L M M L L
-1 -1 1 1 -1 -1 -1 1 1 1 1 1 1 1 -1

测试数据

2

S

实现结果：

测试数据:   特征1 :2   特征2 :S   所属类别：-1