Java——从两个文件读取数据并找出它们重复次数最多的十个数

不考虑两个文件相同数据的重复次数要相加

public class TestDemo6 {

    public static void main(String[] args) {
        File fileA = new File("D:\\A.txt");
        File fileB = new File("D:\\B.txt");
        writer(fileA);
        writer(fileB);
        statistics(fileA);
        System.out.println("文件"+fileA+"==================");
        show(statistics(fileA));
        statistics(fileB);
        System.out.println("文件"+fileB+"==================");
        show(statistics(fileB));
        System.out.println("比较最大"+"==================");
        show(comparev(statistics(fileA),statistics(fileB)));


    }

    /**
     * 给文件写入数据
     * @param fileA
     */
    private static void writer(File fileA) {
        Random random = new Random();
        try {
             FileOutputStream fout = new FileOutputStream(fileA);
             OutputStreamWriter osw = new OutputStreamWriter(fout);
            for(int i = 0;i < 100000;i++) {
                int x = random.nextInt(1000);
                osw.write(x);
              }
            osw.close();
            }catch(IOException e) {
                e.printStackTrace();
            }
        }


    /**
     * 统计文件中出现次数最多的十个数
     * @param fileA
     * @return 
     */
    private static PriorityQueue<Entry<Integer, Integer>> statistics(File fileA) {
        ArrayList<Integer> arraylist = new ArrayList<Integer>();
        Reader reader = null;
        int tmp = 0;
        int len = 0;
        try {
            reader = new FileReader(fileA);
            while((tmp = reader.read()) != -1) {
                arraylist.add(tmp);
                len++;
            }
            reader.close();
        }catch(IOException e) {
            e.printStackTrace();
        }

        Comparator<Map.Entry<Integer,Integer>> comparator = new Comparator<Map.Entry<Integer,Integer>>() {
            public int compare(Map.Entry<Integer,Integer> o1,Map.Entry<Integer,Integer> o2) {
                return o1.getValue() - o2.getValue();
            }
        };

        PriorityQueue<Map.Entry<Integer,Integer>> priorityqueue = new PriorityQueue<Map.Entry<Integer,Integer>>(10,comparator);
        HashMap<Integer,Integer> hashmap = new HashMap<Integer,Integer>();
        Iterator<Integer> iterator = arraylist.iterator();
        while(iterator.hasNext()) {
            Integer next = iterator.next();
            if(!hashmap.containsKey(next)) {
                hashmap.put(next, 0);
            }
            hashmap.put(next, hashmap.get(next)+1);
        }

        Iterator<Entry<Integer,Integer>> iterator1 = hashmap.entrySet().iterator();
        while(iterator1.hasNext()) {
            Entry<Integer,Integer> next = iterator1.next();
            int maxvalue = next.getValue();
            if(priorityqueue.size() < 10) {
                priorityqueue.add(next);
            }else {
                if(priorityqueue.peek().getValue() < maxvalue) {
                    priorityqueue.remove();
                    priorityqueue.add(next);
                }
            }
        }

        return priorityqueue;
    }

    /**
     * 比较得出最大的
     * @param statistics
     * @param statistics2
     * @return 
     */
    private static PriorityQueue<Entry<Integer, Integer>> comparev(PriorityQueue<Entry<Integer, Integer>> priorityqueue1,
            PriorityQueue<Entry<Integer, Integer>> priorityqueue2) {
        Comparator<Map.Entry<Integer,Integer>> comparator = new Comparator<Map.Entry<Integer,Integer>>() {
            public int compare(Map.Entry<Integer,Integer> o1,Map.Entry<Integer,Integer> o2) {
                return o1.getValue() - o2.getValue();
            }
        };


        Iterator<Map.Entry<Integer, Integer>> integer = priorityqueue1.iterator();
        while (integer.hasNext()) {
            Map.Entry<Integer, Integer> next = integer.next();
            if (next.getValue() > priorityqueue2.peek().getValue()) {
                priorityqueue2.remove();
                priorityqueue2.add(next);
            }
        }

        return priorityqueue2;

    }
    /**
     * 打印
     * @param priorityqueue
     */
    public static void show(PriorityQueue<Entry<Integer, Integer>> priorityqueue) {
        Iterator<Map.Entry<Integer,Integer>> iterator2 = priorityqueue.iterator();
        while(iterator2.hasNext()) {
            Map.Entry<Integer, Integer> next = iterator2.next();
            Integer key = next.getKey();
            Integer value = next.getValue();
            System.out.println("数字："+ key +"  重复次数："+value + "  ");
        }
    }

}

运行结果：

文件D:\A.txt==================
数字：120  重复次数：120  
数字：123  重复次数：121  
数字：233  重复次数：122  
数字：65  重复次数：122  
数字：936  重复次数：121  
数字：299  重复次数：124  
数字：110  重复次数：122  
数字：63  重复次数：78108  
数字：937  重复次数：131  
数字：472  重复次数：122  
文件D:\B.txt==================
数字：959  重复次数：118  
数字：926  重复次数：119  
数字：124  重复次数：122  
数字：237  重复次数：122  
数字：105  重复次数：119  
数字：39  重复次数：134  
数字：225  重复次数：123  
数字：7  重复次数：126  
数字：63  重复次数：78211  
数字：919  重复次数：124  
比较最大==================
数字：233  重复次数：122  
数字：919  重复次数：124  
数字：124  重复次数：122  
数字：7  重复次数：126  
数字：299  重复次数：124  
数字：39  重复次数：134  
数字：225  重复次数：123  
数字：63  重复次数：78108  
数字：63  重复次数：78211  
数字：937  重复次数：131