PriorityQueue-数组（二叉堆）

field

    //默认初始化大小
    private static final int DEFAULT_INITIAL_CAPACITY = 11;
    //队列内置为数组，实际为数据结构中的二叉堆
    transient Object[] queue; // non-private to simplify nested class access
    //容量大小
    private int size = 0;
    //比较器
    private final Comparator<? super E> comparator;
    //操作数
    transient int modCount = 0; // non-private to simplify nested class access

construct

    //构造方法，传入初始化容量与比较器。
    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;  //比较器
    }

method

heapify

 private void heapify() {
        //下滤操作，将每个父节点看成重新插入的元素下滤，达到二叉堆结构要求
        for (int i = (size >>> 1) - 1; i >= 0; i--)
            siftDown(i, (E) queue[i]);
    }

siftDownUsingComparator（下滤）

 //下滤指定位置的节点
    //k为数组数组索引，对应二叉堆为 k+1个节点位置
    //左节点 （2k+1） 右节点 （2k + 2）
    private void siftDownUsingComparator(int k, E x) {
        int half = size >>> 1;
        //如果是初始化一个非sorted结合则需要循环下滤
        //下滤，只用从非叶子节点开始下滤即可，即size/2
        while (k < half) {
            int child = (k << 1) + 1;   //左节点
            Object c = queue[child];
            int right = child + 1;   //右节点
            if (right < size &&
                comparator.compare((E) c, (E) queue[right]) > 0)
                //如果左节点大于右节点，取右节点
                c = queue[child = right];
            //将右节点与父节点数据比较，如果父节点大于子节点则下滤，否则不变
            if (comparator.compare(x, (E) c) <= 0)
                break;
            //将x下滤，将c赋值到父节点位置
            queue[k] = c;
            k = child;
        }
        //最后的k位置，即为x的索引坐标
        queue[k] = x;
    }

offer

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

siftUpUsingComparator

private void siftUpUsingComparator(int k, E x) {
        while (k > 0) {
            int parent = (k - 1) >>> 1;  //父节点
            Object e = queue[parent];
            //与父节点判断大小，需要满足父节点大于所有子节点
            if (comparator.compare(x, (E) e) >= 0)
                break;
            queue[k] = e;
            k = parent;
        }
        queue[k] = x;
    }

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);
            //如果尾部元素取代 i 位置元素，则需要上滤判断
            //可能尾部元素比父元素要小
            if (queue[i] == moved) {
                siftUp(i, moved);
                if (queue[i] != moved)
                    return moved;
            }
        }
        return null;
    }