集合--10万随机数问题

1.求十万个数据每个数据出现的次数

import java.util.ArrayList;
import java.util.Random;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
/**
 * 十万数据重复统计并打印
 * 1.10万数据存储
 * 2.数据统计
 * @author lmx
 *
 */
public class A {

	public static void main(String[] args) {
		ArrayList<Integer> x = new ArrayList<Integer>(100000);
		Random random = new Random();
        for(int i = 0;i < 100000;i++) {
            int val = random.nextInt(10);
            x.add(val);
        }
        //对集合进行遍历
        HashMap<Integer,Integer> y = new HashMap<Integer,Integer>();
        Iterator<Integer> z = x.iterator();
        while(z.hasNext()) {
        	Integer d = z.next();
        	if(!y.containsKey(d)) {
        		y.put(d, 0);
        	}
        	y.put(d,y.get(d)+1);
        }
        
        Iterator<Entry<Integer, Integer>> iterator = y.entrySet().iterator();
		while(iterator.hasNext()) {
			Entry<Integer, Integer> h = iterator.next();
			Integer key = h.getKey();
			Integer value = h.getValue();
			System.out.println(key+":"+value);
		}
	}
		
 }

2.十万个随机数求出里面重复次数最多的十个数

import java.util.*;

/**
 * @ClassName TestDemo12
 * @Description 十万个随机数求出里面重复次数最多的十个数
 * @Author lmx
 * @Date 2019/4/5 20:15
 * @Version 1.0
 **/
public class TestDemo12 {
    public static void main(String[] args) {
        fin_10_max();
    }

    private static void fin_10_max() {
        //把100000个数放进ArrayList类型的容器
        ArrayList<Integer> arrayList = new ArrayList<>();
        Random random = new Random();
        //随机插入十万个数据
        for(int i = 0;i < 100000;i++) {
            int val = random.nextInt(10000)+1;
            arrayList.add(val);
        }

        //重写比较器，目的是为了比较的hashmap中的value
        Comparator<Map.Entry<Integer,Integer>> comparator = new Comparator<Map.Entry<Integer, Integer>>() {
            @Override
            public int compare(Map.Entry<Integer, Integer> o1, Map.Entry<Integer, Integer> o2) {
                return o1.getValue()-o2.getValue();
            }
        };

        //创建一个优先级队列的对象。自定义构造函数，则比较器需要重写，大小设为10
        PriorityQueue<Map.Entry<Integer,Integer>> priorityQueue = new PriorityQueue<>(10,comparator);

        //创建一个hashmap对象，（需要记录数以及他的出现次数）
        HashMap<Integer,Integer> hashMap = new HashMap<>();
        //迭代器迭代arraylist，记录每个值出现的次数
        Iterator<Integer> iterator = arrayList.iterator();
        while(iterator.hasNext()) {
            Integer next = iterator.next();
            if(hashMap.containsKey(next)) {
                //记录数据
                hashMap.put(next,hashMap.get(next)+1);
            }else {
                //这个值第一次出现
                hashMap.put(next,1);
            }
        }

        //迭代器迭代hashmap
        Iterator<Map.Entry<Integer,Integer>> iterator1 = hashMap.entrySet().iterator();
        while (iterator1.hasNext()) {
            Map.Entry<Integer,Integer> next = iterator1.next();
            int value = next.getValue();  //得到每一次遍历时的value值
            //如果优先级队列里的数据长度小于10，就往进添加
            if(priorityQueue.size() < 10) {
                priorityQueue.add(next);
            }else {
                //如果数据超过10，比较队顶的元素和要进入的元素
                if(priorityQueue.peek().getValue() < value) {
                    //如果要进入的元素大于队顶的元素，就移除队顶本来的元素，加入新的元素
                    priorityQueue.remove();
                    priorityQueue.add(next);
                }
            }
        }

        //迭代器遍历优先级队列，得出结果
        Iterator<Map.Entry<Integer,Integer>> iterator2 = priorityQueue.iterator();
        System.out.println("数字 出现次数");
        while(iterator2.hasNext()) {
            Map.Entry<Integer,Integer> next = iterator2.next();
            int key = next.getKey();
            int value = next.getValue();
            System.out.println(key+"   "+value);
        }
    }
}