写在前面
版本信息：
JDK1.8
PriorityQueue介绍
在数据结构中，队列分为FIFO、LIFO 两种模型，分别为先进先出，后进后出、先进后出，后进先出（栈） 而一切数据结构都是基于数组或者是链表实现。
在Java中，定义了Queue接口，接口中定义了CRUD的基本方法。分别add、offer、remove、poll等等，而PriorityQueue 实现此接口实现了基本的CRUD的同时拥有了自己的特性，从名字来看也能知道是优先级队列 ： 保持队列头部节点是整条队列中永远是最小或者最大的节点，其实现原理就是一个小顶堆或者大顶堆。上文提及到一切数据结构都是基于数组或者是链表实现，而这里使用了数组实现。
public class PriorityQueue<E> extends AbstractQueue<E>
implements java.io.Serializable {
transient Object[] queue; // 由数组实现
}
public abstract class AbstractQueue<E>
extends AbstractCollection<E>
implements Queue<E> {}小顶堆和大顶堆介绍
从上文描述了PriorityQueue的底层实现是小顶堆或者大顶堆，那么在看源码之前，我们需要先明白小顶堆和大顶堆如何实现～
小顶堆：一颗完全二叉树，其中任意父节点都要小于左右子节点，所以树的根节点是整棵树的最小节点
大顶堆：一颗完全二叉树，其中任意父节点都要大于左右子节点，所以树的根节点是整棵树的最大节点
Comparable和Comparator区别
在看PriorityQueue源码之前还需要分析Comparable和Comparator区别。
Comparable：类需要实现此接口，重写compareTo方法，在compareTo方法中定义比较逻辑，使用时把类强转成Comparable调用compareTo方法，把比较对象传入。所以侵入性比较强，与业务代码强耦合。
Comparator：这个就是一个比较器，只需要把A比较对象和B比较对象都传入即可，不需要于业务代码强耦合
PriorityQueue添加元素源码分析
下文直接把PriorityQueue叫成小顶堆
我们直接从offer方法入手～
public boolean offer(E e) {
if (e == null)
throw new NullPointerException();
modCount++; // 用于检测是否并发
// 因为size从0开始，所以size的值就是数组的索引值。
int i = size;
// 是否需要扩容
if (i >= queue.length)
grow(i + 1);
// 为下次索引+1
size = i + 1;
// 如果是第一个，那么就直接占用数组第一个元素即可，
// 因为不管是小顶堆还是大堆堆第一个都直接插入。
if (i == 0)
queue[0] = e;
else
// 非第一个节点，此时就需要调整
siftUp(i, e);
return true;
}这里的逻辑比较简单，因为这里使用数组实现的小顶堆（也即使用数组实现完全二叉树），而小顶堆的第一个节点是最小的，所以当0索引直接插入即可，非0索引就需要调整小顶堆。这里应该有很多读者是第一次见数组实现二叉树，所以这里把上文的二叉树进行扩展，把数组部分画上去。
在看 siftUp调整方法前，我们看一下grow扩容方法， 因为里面有一个思路大家可以学习～
private void grow(int minCapacity) {
int oldCapacity = queue.length;
// 容量小于64时，扩容为 oldCapacity + oldCapacity +2
// 容量大于64，扩容为 oldCapacity + oldCapacity/2
// 等同于，在容量小的时候，每次扩容大一些，当达到64这个阈值后，扩容小一些，要不然空间会太浪费了～
int newCapacity = oldCapacity + ((oldCapacity < 64) ?
(oldCapacity + 2) :
(oldCapacity >> 1));
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// 数组拷贝迁移。
queue = Arrays.copyOf(queue, newCapacity);
}
在每次扩容的时候，会去判断，当前容量是否大于64，如果小于64就直接 原大小 * 2 + 2 扩容，如果大于64以后直接 原大小 + 原大小/2 扩容。目的是为了在容量小的时候扩容大一些，减少扩容次数。在容量达到64阈值后，扩容小一些，减少内存浪费。
下面开始讲解siftUp调整方法
private void siftUp(int k, E x) {
// 用户是否传入comparator比较器
if (comparator != null)
siftUpUsingComparator(k, x);
else
// 没传入就使用Comparable
// 此时类需要实现Comparable接口
siftUpComparable(k, x);
}这里讲解siftUpComparable方法，本质上两个方法没任何区别～
private void siftUpComparable(int k, E x) {
Comparable<? super E> key = (Comparable<? super E>) x;
while (k > 0) {
// 拿到父节点
// 因为是使用数组实现的一颗完全二叉树，所以直接-1 右移即可拿到当前插入节点的父节点
int parent = (k - 1) >>> 1;
Object e = queue[parent];
// 与父节点做比较。
if (key.compareTo((E) e) >= 0)
// 达到用户的预期比较就直接break，要不然继续往父节点的父节点继续做比较，直到根节点
break;
// 没达到预期，所以把父节点插入到本次插入的节点的位置。
queue[k] = e;
// 拿到父节点的索引，继续往父节点的父节点做比较。
k = parent;
}
// 插入
queue[k] = key;
}这里光看注释，肯定是看不明白的，所以以画图+注释来理解吧～
PriorityQueue获取元素源码分析
直接从poll方法入手～
public E poll() {
if (size == 0)
return null;
// 拿到最后一个节点的索引值。
int s = --size;
modCount++;
// 因为第一个是小顶堆或者大顶堆要的数据。
E result = (E) queue[0];
// 拿到最后一节点
E x = (E) queue[s];
queue[s] = null; // help gc
if (s != 0)
// 调整
siftDown(0, x);
return result;
}因为小顶堆或者大顶堆都是拿第一个元素，所以这里拿出第一个元素。但是每次拿完就需要调整小顶堆（调整完全二叉树），所以看到siftDown方法。
private void siftDown(int k, E x) {
if (comparator != null)
siftDownUsingComparator(k, x);
else
siftDownComparable(k, x);
}本质上这两个方法没任何区别，所以继续看到siftDownComparable方法
// k为0
// x是最后一个节点。
private void siftDownComparable(int k, E x) {
Comparable<? super E> key = (Comparable<? super 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 &&
((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;
}因为每次poll取走的是第一个元素，所以需要调整整个小顶堆，而第一个元素是小顶堆的根节点，所以需要调整小顶堆找到一个符合的元素作为根节点。从根节点的左右子节点开始比较，左右子节点比较出预期的节点就作为新的根节点。预期的节点作为下次比较的父节点，通过父节点再找到他的左右子节点做比较，周而复始，直到最后一个节点。
这里光看注释，肯定是看不明白的，所以以画图+注释来理解吧～
