Java源码阅读-PriorityQueue

/**
     * Priority queue represented as a balanced binary heap: the two
     * children of queue[n] are queue[2*n+1] and queue[2*(n+1)].  The
     * priority queue is ordered by comparator, or by the elements'
     * natural ordering, if comparator is null: For each node n in the
     * heap and each descendant d of n, n <= d.  The element with the
     * lowest value is in queue[0], assuming the queue is nonempty.
     */
    private transient Object[] queue; // 一个数组队列，用于存放元素

插入元素

/**
     * Inserts the specified element into this priority queue.
     *
     * @return {@code true} (as specified by {@link Queue#offer})
     * @throws ClassCastException if the specified element cannot be
     *         compared with elements currently in this priority queue
     *         according to the priority queue's ordering
     * @throws NullPointerException if the specified element is null
     */
    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;
    }

/**
     * Inserts item x at position k, maintaining heap invariant by
     * promoting x up the tree until it is greater than or equal to
     * its parent, or is the root.
     *
     * To simplify and speed up coercions and comparisons. the
     * Comparable and Comparator versions are separated into different
     * methods that are otherwise identical. (Similarly for siftDown.)
     *
     * @param k the position to fill
     * @param x the item to insert
     */
    private void siftUp(int k, E x) {
        if (comparator != null)
            siftUpUsingComparator(k, x);
        else
            siftUpComparable(k, x);
    }

    private void siftUpUsingComparator(int k, E x) { // 传进来的k时刚插入的位置，队列末尾
        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;
    }