1.结构
PriorityQueue 继承关系，核心成员变量及主要构造函数：
// 可以看到 PriorityQueue 只是一个普通队列，并不是一个阻塞队列
public class PriorityQueue<E> extends AbstractQueue<E> implements java.io.Serializable {
// 通过数组保存队列数据，队列节点是Object
// 这里采用的其实是堆这种数据结构，后面元素的排序也是采用的堆排序
transient Object[] queue;
transient int modCount = 0;
private int size = 0
// 比较器，priortyqueue是优先队列，所以比较器是必须的
private final Comparator<? super E> comparator;
// 数组默认初始容量
private static final int DEFAULT_INITIAL_CAPACITY = 11;
// 数组最大容量
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
//----------------------------------构造函数------------------------------
// 构造函数一：空参构造
public PriorityQueue() {
// 默认初始容量，无比较器
this(DEFAULT_INITIAL_CAPACITY, null);
}
// 构造函数二：传入自定义比较器
public PriorityQueue(Comparator<? super E> comparator) {
// 默认初始容量，自定义比较器
this(DEFAULT_INITIAL_CAPACITY, comparator);
}
// 构造函数三：传入指定容量和比较器
public PriorityQueue(int initialCapacity, Comparator<? super E> comparator) {
if (initialCapacity < 1)
throw new IllegalArgumentException();
// 数组初始化
this.queue = new Object[initialCapacity];
this.comparator = comparator;
}
}
1.1 堆简介
堆在逻辑上一棵完全二叉树，所以可以通过数组进行数据存储，而其余的树大多采用链式结构进行数据存储
- 堆分类：
- 大顶堆：大顶堆就是无论在任何一棵（子）树中，父节点都是最大的
- 小顶堆：小顶堆就是无论在任何一棵（子）树中，父节点都是最小的。PriortyQueue 采用的就是小顶堆
- 堆的两种操作：
- 上浮：一般用于向堆中添加新元素后的堆平衡
- 下沉：一般用于取出堆顶并将堆尾换至堆顶后的堆平衡
- 堆排序：利用大顶堆和小顶堆的特性，不断取出堆顶，取出的元素就是堆中元素的最值，然后再使堆平衡
这里只做简介，想了解堆的代码实现及更多操作的同学可以参考 【数据结构】Java实现堆：堆的各种操作&堆排序。
1.2 Comparable 对比 Comparator
这里再说一下 Comparable 接口和 Comparator 接口，它俩的作用都是提供了同一类型下不同对象实体比较的方式，所以这里主要关注它们的区别：
- Comparable 接口
- 一般用作内部比较器，需要实体对象实现Comparable接口并重写 compareTo 方法
- 比较时调用实体对象的 compareTo 方法
public interface Comparable<T> {
public int compareTo(T o);
}
- Comparator 接口
- 一般用作外部比较器，提前写好实现类并重写compare方法后，然后作为参数传入需要比较器的方法。
- 比较时直接向比较器中传入两个需要比较的对象。下面是一个示例：
// Comparator作为参数，匿名类，省略实现
// Dog：要比较的类型
Collections.sort(list, new Comparator<Dog>() {
// 重写compare方法，参数是两个待比较的对象
public int compare(Dog o1, Dog o2) {
// 比较策略
return o2.age - o1.age;
}
});
这里注意一点，因为Comparator是接口所以不能new，但可作为匿名类相当于省略了实现类。
2.方法解析 & api
2.1 入队
add()
public boolean add(E e) {
// 调用offer
return offer(e);
}
offer()
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; // size++
if (i == 0)
// 如果队列为空直接将元素放到队首
queue[0] = e;
else
// 上浮
// 可以这么理解，队列（数组）中所有元素已经是排好序的，而新元素会追加到数组末尾，所以为了保证总体有序，可能需要将新元素上浮（前移）
siftUp(i, e);
return true;
}
siftUp()
判断比较时是用自定义比较器Comparator，还是用对象实体的 compareTo 方法
private void siftUp(int k, E x) {
if (comparator != null)
// 有自定义比较器，就用自定义比较器，调用 siftUpUsingComparator
siftUpUsingComparator(k, x);
else
// 无自定义比较器，就用元素的Comparable方法，调用 siftUpComparable
siftUpComparable(k, x);
}
siftUpComparable
通过实体对象的 compareTo 方法进行比较，完成新元素的上浮，使队列（数组）总体顺序是：小 => 大。具体过程请看注释：
// k：当前队列实际大小的位置（没有新元素），x：要插入的元素
private void siftUpComparable(int k, E x) {
// 将x强转为Comparable，可以调用CompareTo比较
Comparable<? super E> key = (Comparable<? super E>) x;
// 通过不断与父节点进行比较，最后找到正确的位置
while (k > 0) {
int parent = (k - 1) >>> 1; // 得到k的父节点索引，即对 k 进行减倍
Object e = queue[parent]; // 得到父节点的数据
if (key.compareTo((E) e) >= 0) // 如果 x 比 parent 大，表示当前位置就是正确的位置
break;
queue[k] = e; // x 比 parent 小，则将parent交换到x的位置
k = parent; // 继续上浮，直到找到一个比 x 小的 parent
}
queue[k] = key; // 已将找到了合适的位置，将 x 放入
}
2.2 出队：poll
出队其实就是将队首，也即小顶堆的堆顶返回，然后通过下沉操作使堆恢复。
public E poll() {
if (size == 0)
return null;
int s = --size; // size--
modCount++;
// 取队首
E result = (E) queue[0];
// 保存数组最后一个元素，也即堆尾
E x = (E) queue[s];
// 将堆尾删除
queue[s] = null;
if (s != 0)
// 下沉（将堆尾x放到堆顶位置，然后下沉）
siftDown(0, x);
return result;
}
2.3 获取队首：peek
public E peek() {
// 直接将arr[0]返回
return (size == 0) ? null : (E) queue[0];
}
2.4 扩容：grow
扩容的本质就是数组拷贝，所以问题就在于新数组到底要多大：
- oldCap < 64 —> newCap = oldCap*2 + 2
- oldCap >= 64 —> newCap = oldCap * 2
- newCap > Max —> newCap = Integer.MAX_VALUE
private void grow(int minCapacity) {
int oldCapacity = queue.length;
// newCap
int newCapacity = oldCapacity + ((oldCapacity < 64) ?
(oldCapacity + 2) :
(oldCapacity >> 1));
// 防止溢出，即超出最大容量
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// 将拷贝后的大数组再赋给queue
queue = Arrays.copyOf(queue, newCapacity);
}