【Java】PriorityQueue 源码分析

一、PriorityQueue介绍

　　PriorityQueue 是基于优先级堆的无限优先级queue 。 优先级队列的元素根据它们的有序natural ordering ，或由一个Comparator在队列构造的时候提供，这取决于所使用的构造方法。 优先队列不允许null元素。 依靠自然排序的优先级队列也不允许插入不可比较的对象（这样做可能导致ClassCastException ）。

　　该队列的头部是相对于指定顺序的最小元素（即最小堆数据结构）。 如果多个元素被绑定到最小值，那么头就是这些元素之一 - 关系被任意破坏。 队列检索操作poll ， remove ， peek和element访问在队列的头部的元件。

　　优先级队列是无限制的，但是具有管理用于在队列上存储元素的数组的大小的内部容量 。 它始终至少与队列大小一样大。 当元素被添加到优先级队列中时，其容量会自动增长。 没有规定增长政策的细节。

二、属性

// 默认队列容量
private static final int DEFAULT_INITIAL_CAPACITY = 11;

// 数据数组
transient Object[] queue;

// 队列大小
private int size = 0;

// 比较器
private final Comparator<? super E> comparator;

// 修改次数
transient int modCount = 0;

三、方法

1、构造方法

// 创建默认优先级队列，队列默认容量为11，其中数据数组已创建
public PriorityQueue() {
    this(DEFAULT_INITIAL_CAPACITY, null);
}

// 根据初始值容量创建优先级队列
public PriorityQueue(int initialCapacity) {
    this(initialCapacity, null);
}

// 根据创建比较器，默认容量为11优先级队列
public PriorityQueue(Comparator<? super E> comparator) {
    this(DEFAULT_INITIAL_CAPACITY, comparator);
}

// 根据初始值容量，比较器，创建队列
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;
}

// 根据集合创建优先级队列
@SuppressWarnings("unchecked")
public PriorityQueue(Collection<? extends E> c) {
    if (c instanceof SortedSet<?>) {
        SortedSet<? extends E> ss = (SortedSet<? extends E>) c;
        this.comparator = (Comparator<? super E>) ss.comparator();
        initElementsFromCollection(ss);
    }
    else if (c instanceof PriorityQueue<?>) {
        PriorityQueue<? extends E> pq = (PriorityQueue<? extends E>) c;
        this.comparator = (Comparator<? super E>) pq.comparator();
        initFromPriorityQueue(pq);
    }
    else {
        this.comparator = null;
        initFromCollection(c);
    }
}

// 根据原优先级队列创建队列
@SuppressWarnings("unchecked")
public PriorityQueue(PriorityQueue<? extends E> c) {
    this.comparator = (Comparator<? super E>) c.comparator();
    initFromPriorityQueue(c);
}

// 根据SortSet集合创建优先级队列
@SuppressWarnings("unchecked")
public PriorityQueue(SortedSet<? extends E> c) {
    this.comparator = (Comparator<? super E>) c.comparator();
    initElementsFromCollection(c);
}

2、add() 和 offer() 方法

// 添加元素到队列中 
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;
}

　　注：不明白二叉堆-最小堆的可百度，即可理解原理

3、grow() 方法

// 扩容
private void grow(int minCapacity) {
    int oldCapacity = queue.length;
    // Double size if small; else grow by 50%
    // 1、原容量小于 64，新容量为原容量的2倍+2
    // 2、原容量不小于 64，新容量为原容量的1.5倍
    int newCapacity = oldCapacity + ((oldCapacity < 64) ?
                                     (oldCapacity + 2) :
                                     (oldCapacity >> 1));
    // overflow-conscious code
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        // 新容量大于数组最大长度时，新容量为：Integer.MAX_VALUE，否则为：MAX_ARRAY_SIZE
        newCapacity = hugeCapacity(minCapacity);
    // 复制数据到新数组
    queue = Arrays.copyOf(queue, newCapacity);
}

4、siftUp() 方法

// 筛选 siftUp
private void siftUp(int k, E x) {
    if (comparator != null)
        siftUpUsingComparator(k, x);
    else
        siftUpComparable(k, x);
}

// 使用选择器上浮
@SuppressWarnings("unchecked")
private void siftUpComparable(int k, E x) {
    Comparable<? super E> key = (Comparable<? super E>) x;
    while (k > 0) {
        int parent = (k - 1) >>> 1;
        Object e = queue[parent];
        if (key.compareTo((E) e) >= 0)
            break;
        queue[k] = e;
        k = parent;
    }
    queue[k] = key;
}

// 使用选择器上浮
@SuppressWarnings("unchecked")
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;
}

5、poll() 方法

public E poll() {
    if (size == 0)
        return null;
    int s = --size;
    modCount++;
    // 因为数据时最小堆，所以queue[0]最小
    E result = (E) queue[0];
    E x = (E) queue[s];
    queue[s] = null;
    if (s != 0)
        // 二叉堆存储
        // 下浮
        siftDown(0, x);
    return result;
}

6、siftDown() 方法

private void siftDown(int k, E x) {
        if (comparator != null)
            siftDownUsingComparator(k, x);
        else
            siftDownComparable(k, x);
    }

    @SuppressWarnings("unchecked")
    private void siftDownComparable(int k, E x) {
        Comparable<? super E> key = (Comparable<? super E>)x;
        int half = size >>> 1;        // loop while a non-leaf
        while (k < half) {
            int child = (k << 1) + 1; // assume left child is least
            Object c = queue[child];
            int right = child + 1;
            if (right < size &&
                ((Comparable<? super E>) c).compareTo((E) queue[right]) > 0)
                c = queue[child = right];
            if (key.compareTo((E) c) <= 0)
                break;
            queue[k] = c;
            k = child;
        }
        queue[k] = key;
    }

    @SuppressWarnings("unchecked")
    private void siftDownUsingComparator(int k, E x) {
        int half = size >>> 1;
        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;
            queue[k] = c;
            k = child;
        }
        queue[k] = x;
    }

四、示例代码

/**
 * 优先级队列
 * 数据存储使用的是数组存，结构是最小堆，即顶上元素最小
 */
public class TestPriorityQueue {

    public static void main(String[] args) {

        PriorityQueue<Integer> queue = new PriorityQueue<>(10, (Integer::compare));
        queue.add(1);
        queue.add(7);
        queue.add(8);
        queue.add(2);
        queue.add(3);
        queue.add(9);
        queue.add(5);
        queue.add(4);
        queue.add(6);

        System.out.println(queue);
        for (int i = 0; i < 5; i++) {
            System.out.println(queue.poll());
        }
        System.out.println(queue);

    }
}

五、总结

　　1、PriorityQueue 采用数组来存储数据的，数据结构是最小堆

　　2、PriorityQueue 扩容时

　　　　- 原容量小于 64，新容量为原容量的2倍+2

　　　　- 原容量不小于 64，新容量为原容量的1.5倍

　　3、放入元素，需要使用siftUp() 上浮方法，保证最小堆结构

　　4、取出元素，需要使用downtUp() 下浮方法，保证最小堆结构

　　5、PriorityQueue 非线程安全的，线程安全可以使用 PriorityBlockingQueue