1类签名与简介
public class PriorityQueue<E> extends AbstractQueue<E> implements java.io.Serializable
PriorityQueue是一个基于优先级堆的无限队列，无限的意思是说队列的容量可以自动扩容，最大容量为整形最大值。扩容规定如下当容量小于64时扩大为原来的2倍，否则扩大为原来的1.5倍（也就是容量增大50%）。
优先级队列不允许null元素，也不允许插入不可比较的对象。不可比较是指待插入对象的类没有实现Comparable接口，或者构造PriorityQueue对象是没有提供一个待插入对象的comparator比较器。强行插入不可比较对象会报ClassCastException异常。举个例子，现有一个Student类，只有以下两种情况才能将Student的对象放入PriorityQueue中：
（1）Student实现Comparable接口
（2）new PriorityQueue时提供一个Student的比较器：Queue<Student> students = new PriorityQueue<>(new MyComparator())
该队列的头部是相对于指定顺序的最小元素。 如果多个元素被绑定到最小值，那么头就是这些元素之一。
优先级堆（小顶堆）是用数组实现的，对于小顶堆的性质请执行查阅相关数据结构。入队出队的方法时间复杂度都是O（logn）。
请注意，此实现不同步。若想要在多线程并发，请使用线程安全的PriorityBlockingQueue类。
2 入队
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; }
add和offer都是入队实现，add其实就是调用offer方法实现的，所以两者本质上没有区别。
offer首先会判断插入元素是否为null，优先队列不允许插入null的元素。接下来判断队列是否满了，满了就扩容。如果插入的是队列第一个元素就直接放在数组0号位。否则就进行上移调整siftUp。上移调整是从堆的最后一个节点（也就是队尾）开始不断通过比较parent节点找到插入的位置。
private void siftUp(int k, E x) { if (comparator != null) siftUpUsingComparator(k, x); else siftUpComparable(k, x); } //实现Comparable接口的情况 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; } //提供比较器Comparator的情况 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; }
每次插入都进行siftUp保证了始终是一个小顶堆，不会因为新的节点破坏堆的结构。
siftUpComparable和siftUpUsingComparator过程是一样的，唯一不同的是不同的接口调用的不同比较方法。
3出队
出队是移除队列队头的元素，即数组的0号位存储的元素，也是堆结构的堆顶。
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; if (s != 0) siftDown(0, x); return result; }
poll原理如下，把最后一个元素放到堆顶（数组0号位），然后从堆顶开始往下调整siftDown，直到满足最小堆为止。siftDown实现过程如下
private void siftDown(int k, E x) { if (comparator != null) siftDownUsingComparator(k, x); else siftDownComparable(k, x); } //内部排序接口调用siftDownComparable 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; } //有外部比较器调用siftDownUsingComparator 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; }
4总结
关于本篇文章，个人感觉描述的不是很清楚。
因为觉得不适合花费其他篇幅去详细介绍“Comparator与Comparable”以及堆排序等相关知识。如果觉得有问题的话建议先了解一下这些相关的基础知识。