（7）PriorityQueue总结

1.概念

如果我们给每个元素都分配一个数字来标记其优先级，不妨设较小的数字具有较高的优先级，这样我们就可以在一个集合中访问优先级最高的元素并对其进行查找和删除操作了。这样，我们就引入了优先级队列 这种数据结构。 优先级队列（priority queue） 是0个或多个元素的集合，每个元素都有一个优先权，对优先级队列执行的操作有（1）查找（2）插入一个新元素 （3）删除 一般情况下，查找操作用来搜索优先权最大的元素，删除操作用来删除该元素 。对于优先权相同的元素，可按先进先出次序处理或按任意优先权进行。

public class PriorityQueue<E> extends AbstractQueue<E>
    implements java.io.Serializable 

2.构造方法

无参：默认大小为11

    public PriorityQueue() {
        this(DEFAULT_INITIAL_CAPACITY, null);
    }

有参：指定大小

    public PriorityQueue(int initialCapacity) {
        this(initialCapacity, null);
    }

有参：

    public PriorityQueue(int initialCapacity,
                         Comparator<? super E> comparator) {
        // Note: This restriction of at least one is not actually needed,
        // but continues for 1.5 compatibility
        if (initialCapacity < 1)
            throw new IllegalArgumentException();
        this.queue = new Object[initialCapacity];
        this.comparator = comparator;
    }

3.grow方法扩容

1.5倍方式扩容

    private void grow(int minCapacity) {
        int oldCapacity = queue.length;
        // Double size if small; else grow by 50%
        int newCapacity = oldCapacity + ((oldCapacity < 64) ?
                                         (oldCapacity + 2) :
                                         (oldCapacity >> 1));
        // overflow-conscious code
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        queue = Arrays.copyOf(queue, newCapacity);
    }

4.add方法

    public boolean add(E e) {
        return offer(e);
    }

    public boolean offer(E e) {
        if (e == null)
            throw new NullPointerException();
        modCount++;
        int i = size;
        if (i >= queue.length)
            grow(i + 1);
        size = i + 1;
        if (i == 0)
            queue[0] = e;
        else
            siftUp(i, e);
        return true;
    }

5.peek、poll方法

peek：返回最前面的值

    public E peek() {
        if (size == 0)
            return null;
        return (E) queue[0];
    }

poll：返回最前面的值，并且删除

    public E poll() {
        if (size == 0)
            return null;
        int s = --size;
        modCount++;
        E result = (E) queue[0];
        E x = (E) queue[s];
        queue[s] = null;
        if (s != 0)
            siftDown(0, x);
        return result;
    }

6.indexOf方法

找到某个元素的下标

    private int indexOf(Object o) {
        if (o != null) {
            for (int i = 0; i < size; i++)
                if (o.equals(queue[i]))
                    return i;
        }
        return -1;
    }

7.remove、removeAt方法

remove：移除某个元素

    public boolean remove(Object o) {
        int i = indexOf(o);
        if (i == -1)
            return false;
        else {
            removeAt(i);
            return true;
        }
    }

removeAt：移除某个下标的元素

    private E removeAt(int i) {
        assert i >= 0 && i < size;
        modCount++;
        int s = --size;
        if (s == i) // removed last element
            queue[i] = null;
        else {
            E moved = (E) queue[s];
            queue[s] = null;
            siftDown(i, moved);
            if (queue[i] == moved) {
                siftUp(i, moved);
                if (queue[i] != moved)
                    return moved;
            }
        }
        return null;
    }

8.contains方法

检查某一元素是否存在

    public boolean contains(Object o) {
        return indexOf(o) != -1;
    }

打印出10000个元素中出现次数最多的10个元素

public class PriorityQueue1 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        /**
         * 小根堆
         */
        PriorityQueue<Map.Entry<Integer, Integer>> p1 = new PriorityQueue<Map.Entry<Integer, Integer>>(10,new Comparator<Map.Entry<Integer, Integer>>()
        {
            @Override
            public int compare(Map.Entry<Integer, Integer> o1, Map.Entry<Integer, Integer> o2) {
            // TODO Auto-generated method stub
                return o1.getValue()-o2.getValue();
            }
    });
        /**
         * 产生10000个随机数
         */
        ArrayList<Integer> array = new ArrayList<Integer>();
        Random random = new Random();
        for (int i = 0; i < 10000; i++) {
            array.add(random.nextInt(100));
        }
        /**
         * 统计重复次数
         * key:值
         * value：重复次数
         */
        HashMap<Integer,Integer> hashMap = new HashMap<Integer,Integer>();
        Iterator<Integer> iterator = array.iterator();
        while (iterator.hasNext()) {
            Integer integer = (Integer) iterator.next();
            if(!hashMap.containsKey(integer)) {
                hashMap.put(integer, 0);
            }
            hashMap.put(integer, hashMap.get(integer)+1);
        }
        /**
         *寻找10个出现次数最多的元素
         */
        Iterator<Map.Entry<Integer, Integer>> iterator1 = hashMap.entrySet().iterator();
        while(iterator1.hasNext()){
            Entry<Integer, Integer> entry = iterator1.next();
            if(p1.size()<10){
                p1.add(entry);
            }else{
                if(p1.peek().getValue()<entry.getValue()){
                    p1.remove();
                    p1.add(entry);
                }
            }
        }
        System.out.println(p1);
    }

}

打印出10000个元素中出现次数最少的10个元素

public class PriorityQueue2 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        /**
         * 大根堆
         */
        PriorityQueue<Map.Entry<Integer, Integer>> p1 = new PriorityQueue<Map.Entry<Integer, Integer>>(10,new Comparator<Map.Entry<Integer, Integer>>()
        {
            @Override
            public int compare(Map.Entry<Integer, Integer> o1, Map.Entry<Integer, Integer> o2) {
            // TODO Auto-generated method stub
                return o2.getValue()-o1.getValue();
            }
    });
        /**
         * 产生10000个随机数
         */
        ArrayList<Integer> array = new ArrayList<Integer>();
        Random random = new Random();
        for (int i = 0; i < 100000; i++) {
            array.add(random.nextInt(10000));
        }
        /**
         * 统计重复次数
         * key:值
         * value：重复次数
         */
//      int[] arrayTest = {1,2,3,4,5,6,4,3,6,5,8,5,3,5,6,3,7};
//      for (int i = 0; i < arrayTest.length; i++) {
//          array.add(arrayTest[i]);
//      }
        HashMap<Integer,Integer> hashMap = new HashMap<Integer,Integer>();
        Iterator<Integer> iterator = array.iterator();
        while (iterator.hasNext()) {
            Integer integer = (Integer) iterator.next();
            if(!hashMap.containsKey(integer)) {
                hashMap.put(integer, 0);
            }
            hashMap.put(integer, hashMap.get(integer)+1);
        }
        /**
         *寻找10个出现次数最少的元素
         */
        Iterator<Map.Entry<Integer, Integer>> iterator1 = hashMap.entrySet().iterator();
        while(iterator1.hasNext()){
            Entry<Integer, Integer> entry = iterator1.next();
            if(p1.size()<10){
                p1.add(entry);
            }else{
                if(p1.peek().getValue() > entry.getValue()){
                    p1.remove();
                    p1.add(entry);
                }
            }
        }
        System.out.println(p1);
    }

}