PriorityQueue

优先级队列： PriorityQueue
1、特点：
不能添加null元素
可重复
默认构建的是小顶堆
2、应用场景：
查找数据中前100大的数据；
查找数据中前100小的数据；
3、数据结构：object[ ]数组
大根堆，小根堆
4、底层源码分析：
（1）继承关系：
继承：AbstractQueue
实现： java.io.Serializable
（2）构造函数：

 int newCapacity = ((oldCapacity < 64)?
                           ((oldCapacity + 1) * 2):
                           ((oldCapacity / 2) * 3));
        if (newCapacity < 0) // overflow
            newCapacity = Integer.MAX_VALUE;
        if (newCapacity < minCapacity)
            newCapacity = minCapacity;
        queue = Arrays.copyOf(queue, newCapacity)
      <1.7.....>

（3）基本属性：

Object[] queue;
int DEFAULT_INITIAL_CAPACITY = 11 ;
int size = 0;
Comparator<? super E> comparator;

5、方法：
boolean add （E e） : 调用的offer，
boolean offer（E e） :添加指定元素到优先级队列中, 如果元素为null抛出异常
boolean remove( ) :删除头结点 （父类方法），队列为空，抛出异常
boolean remove（E e） ： 删除队列指定元素
E peek（）： 获取队列头部元素，但不删除，队列为空，返回null
E element（）：获取头结点，（父类方法），队列为空，抛出异常
E poll( ) :删除并且返回队列的头部，如果队列为空，返回null

大根堆：

public class MaxHeap {
    int size;
    Node [] arr;

    class Node{
        int val;
        Node (int val) {
            this.val = val;
        }
    }
    
    MaxHeap() {
        arr = new Node[100];
    }
    /*
        将新添的元素放在最后一个位置，然后依次判断此元素和父类元素的大小关系，
        如果新元素大于父节点，二者交换位置，继续比较新元素和新的父节点的大小
        关系，如果新元素的值小于父亲元素，将新元素放当前位置；依次循环，直至
        index>0;
    */
    public void add(int val) {
        if (size==0) {
            arr[size++] = new Node(val);
            return;
        }

        int index = size;
        while (index > 0) {
            //获得父节点
            int father = (index - 1)>>1;
            if (arr[father].val>val) {
                break;
            }
            arr[index] = arr[father];
            index = father;
        }
        arr[index] = new Node(val);
        size++;
    }

//默认删除第一个数据
/*
    默认删除第一个节点：首先得到最后一个节点（temp），然后从首节点位置开始，往下
    找子节点中值最大的（max），拿temp和max比较，如果temp大，就直接放到首节点位置，
    如果max大，将temp和和max交换位置，然后指针向下移动， 依次循环，直至
    index< (size>>>1)

*/
    public void remove () {
        if (size== 0) {
            return;
        }
        int index = 0;
        int val = arr[--size].val;  //获得最后一个值

        while (index < size>>>1) {
            //获得最大的子节点
            int max = (index<<1) +1;
            int right = max +1;
            //此处进行对右孩子下标做越界判断

            if (right<size && arr[right].val>arr[max].val) {
                max = right;
            }
            if (val > arr[max].val) {
                break;
            }
            arr[index].val  = arr[max].val;
            index = max;
        }
        arr[index].val = val;
    }