把100000个随机数存进指定文件中，并读取出这100000个数中重复次数最多的10个数

package tulun_study;


import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Random;

/**  
* 描述：TODO
*  
* @author ASUS  
* @date 2018年7月27日
*/
public class FileContainDemo {

	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void creatFile() throws IOException {
		  File file=  new  File("D:/aiaia.txt"); 
		     try {
				FileWriter fos = new FileWriter(file);
				Random random = new Random();
				for(int i = 0;i < 100000;i++) {//定义1000000个数据
					int val = random.nextInt(1000);//在数值0~1000内产生随机整数
					fos.write(String.valueOf(val)+"\r\n");
				}
				
				fos.close();
			} catch (FileNotFoundException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
	}
	
	public static void findMinData() throws IOException {
		    File file=  new  File("D:/aiaia.txt"); 
			
		   ArrayList<Integer> arraylist = new ArrayList<Integer>();	
		   BufferedReader bfr = new BufferedReader(new FileReader(file));
		   String s = null;
		   while((s = bfr.readLine()) != null) {
					arraylist.add(Integer.parseInt(s));
			}
			bfr.close();
		
	    HashMap<Integer,Integer> hashmap = new HashMap<Integer,Integer>();
	    //迭代器迭代arraylist，记录每个值出现的次数
	    Iterator<Integer> iterator = arraylist.iterator();
	    while(iterator.hasNext()) {
	    	Integer integer = iterator.next();
	    	//如果没找到Key，证明这个值没有出现，就给value（重复次数）赋值0
	    	if(!hashmap.containsKey(integer)) {
	    		hashmap.put(integer, 0);
	    	}
	    	//记录数据
	    	hashmap.put(integer, hashmap.get(integer) + 1);
	    }
	    
	         //重写比较器，目的是为了比较的hashmap中的value
	  		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();//o2-o1
	  			}
	  	    };
	  	   
	  	 //创建一个优先级队列的对象。自定义构造函数，则比较器需要重写（根据需求写大小跟堆），堆大小设为10
	    PriorityQueue<Map.Entry<Integer,Integer>> priorityqueue1 = new PriorityQueue<Map.Entry<Integer,Integer>>(10,comparator);
	    //迭代器迭代hashmap
	    Iterator<Map.Entry<Integer, Integer>> iterator1 = hashmap.entrySet().iterator();
	    while(iterator1.hasNext()) {
	    	Map.Entry<Integer,Integer> next = iterator1.next();
	    	//得到遍历时每一次的value值
	    	int newValue = next.getValue();
	    	//如果优先级队列里的数据长度小于10，就往进添加
	    	if(priorityqueue1.size() < 10) {
	    		priorityqueue1.add(next);
	    	//如果数据超过10，比较队顶的元素和要进入的元素
	    	} else {
	    		//如果要进入的元素大于堆顶的元素，就移除队顶本来的元素，加入新的元素，实现根堆里的数是最大的10个数
	    		if(priorityqueue1.peek().getValue() < newValue) {//>
	    			priorityqueue1.remove();
	    			priorityqueue1.add(next);
	    		}
	    	}
	    	
	    }
	    /*
	     * 迭代器遍历优先级队列，得出结果
        */	
	    Iterator<Map.Entry<Integer, Integer>> iterator2 = priorityqueue1.iterator();
		while(iterator2.hasNext()) {
			Map.Entry<Integer, Integer> next = iterator2.next();
			Integer key = next.getKey();
			Integer value = next.getValue();
			System.out.println("数字："+ key +"  重复次数："+value + "  ");
		}
	}
	
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		
		creatFile();
		findMinData();
	}

}