（七）PriorityQueue（优先级队列）

PriorityQueue

——特点

重复性：存储的元素可以重复

null值：队列中元素不能为null

有序性：不能保证数据的完全有序

注：PriorityQueue中存储自定义类型需要实现Comparable接口，否则会抛出异常

——练习：统计10万个1~1000的数据出现的次数，并打印出出现次数最多的10个元素和该数据出现的次数

package com.demo.demo0305;




import java.util.*;

/**
 * 十万个1~1000
 * 统计出现次数
 * 打印出出现次数最多的十个数
 * 并打印该数据出现的次数
 */

public class Demo0305_2 {


    public static void main(String[] args) {

        //数据产生
        Random random = new Random();
        ArrayList<Integer> arrayList = new ArrayList<>();
        for (int i = 0;i < 100000;i ++){
            Integer n = random.nextInt(1000) + 1;
            arrayList.add(n);
        }

        //遍历
        Iterator<Integer> iterator = arrayList.iterator();
        //统计结果并存储在HashMap
        HashMap<Integer,Integer> hashMap = new HashMap<>();
        Integer key;
        Integer val;
        while(iterator.hasNext()){
            Integer next = iterator.next();
            key = next;
            if(hashMap.containsKey(next)){
                val = hashMap.get(key) + 1;
            }else{
                val = 1;
            }
            hashMap.put(key,val);
        }


        //比较器
        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 o2.getValue() - o1.getValue();
            }
        };

        //优先级队列排序
        PriorityQueue<Map.Entry<Integer,Integer>> priorityQueue = new PriorityQueue<>(1000,comparator);

        Iterator<Map.Entry<Integer,Integer>> iterator1 = hashMap.entrySet().iterator();

        while(iterator1.hasNext()){
            Map.Entry<Integer,Integer> entry = iterator1.next();
            priorityQueue.add(entry);
        }

        //Iterator<Integer> iterator2 = priorityQueue.iterator();
        for(int i = 0;i < 10;i ++){
            Map.Entry<Integer,Integer> top = priorityQueue.poll();
            Integer key_top = top.getKey();
            Integer val_top = top.getValue();
            System.out.print(key_top + "---" + val_top + " ");
        }
        System.out.println();
    }
}

package com.demo.demo0305;

import java.util.*;

/**
 * 十万个1~1000
 * 统计出现次数
 * 打印出出现次数最多的十个数
 * 并打印该数据出现的次数
 */

public class Test_1 {

    //十万数据
    public static ArrayList<Integer> number(){
        ArrayList<Integer> arrayList = new ArrayList<>();
        Random random = new Random();
        for(int i = 0;i < 100000;i ++){
            int n = random.nextInt(1000) + 1;
            arrayList.add(n);
        }
        return arrayList;
    }

    //统计
    public static PriorityQueue<Map.Entry<Integer,Integer>> top_ten(ArrayList<Integer> arrayList){

        //遍历arrayList，并将统计结果存入HashMap
        Iterator<Integer> iterator = arrayList.iterator();
        HashMap<Integer,Integer> hashMap = new HashMap<>();
        Integer key;
        Integer val;
        while(iterator.hasNext()){
            Integer next = iterator.next();
            key = next;
            if(hashMap.containsKey(next)){
                val = hashMap.get(next) + 1;
            }else{
                val = 1;
            }
            hashMap.put(key,val);
        }

        //遍历hashMap，存入优先级队列，获得最终结果
        Iterator<Map.Entry<Integer,Integer>> entryIterator = hashMap.entrySet().iterator();

        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();
            }
        };

        PriorityQueue<Map.Entry<Integer,Integer>> priorityQueue = new PriorityQueue<>(10,comparator);

        while(entryIterator.hasNext()){
            Map.Entry<Integer,Integer> entry = entryIterator.next();
            if(priorityQueue.size() < 10){
                priorityQueue.add(entry);
            }else{
                Integer top = priorityQueue.peek().getValue();
                if(entry.getValue() > top){
                    priorityQueue.remove();
                    priorityQueue.add(entry);
                }
            }
        }
        return priorityQueue;
    }

    public static void show(PriorityQueue<Map.Entry<Integer,Integer>> priorityQueue){
        Iterator<Map.Entry<Integer,Integer>> iterator = priorityQueue.iterator();
        while(iterator.hasNext()){
            Map.Entry<Integer,Integer> entry = iterator.next();
            Integer key = entry.getKey();
            Integer val = entry.getValue();
            System.out.print(key + "---" + val + ",");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        ArrayList<Integer> arrayList = number();
        show(top_ten(arrayList));

    }
}