优先队列不是绝对标准的队列实现，每次出队的元素都是优先级最高的元素。不允许添加null元素。
优先队列的元素有两种排序方式：自然排序和定制排序。
自然排序：优先队列集合中元素实现的Comparable接口。
定制排序：创建队列时传进的Comparator对象。
采用了小顶堆的实现方式，保证了每次poll都是最小的元素(也可根据自定义的比较器)。
1.成员变量：
2.构造器：未传入数组的初始化长度则默认长度为11。未传入比较器则默认为null，前提是元素类必须实现了Comparable接口。
//其实上边所说的几种构造器最终会走到该构造器 public PriorityQueue(int initialCapacity, Comparator<? super E> comparator) { //对传入的参数进行判断，小于1则抛出异常 if (initialCapacity < 1) throw new IllegalArgumentException(); //初始化数组 this.queue = new Object[initialCapacity]; this.comparator = comparator; }
传入的是集合：在代码中我们可以看到首先判断集合的类型是否为SortedSet或PriorityQueue，因为这两个类元素类实现了Comparable接口或者定义的时候传进了Comparator对象。所以比较器一定不为空
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<?>) { java.util.PriorityQueue<? extends E> pq = (java.util.PriorityQueue<? extends E>) c; this.comparator = (Comparator<? super E>) pq.comparator(); initFromPriorityQueue(pq); } else { this.comparator = null; initFromCollection(c); } } private void initElementsFromCollection(Collection<? extends E> c) { //将集合转为数组 Object[] es = c.toArray(); int len = es.length; //若c的运行时类型不为Object，则将该数组转为Object类型 if (es.getClass() != Object[].class) es = Arrays.copyOf(es, len, Object[].class); if (len == 1 || this.comparator != null) for (Object e : es) if (e == null) throw new NullPointerException(); //该方法主要是判断es的长度是否大于0，是就返回该数组，不是则new一个长度为1的Object数组， this.queue = ensureNonEmpty(es); this.size = len; } private void initFromPriorityQueue(PriorityQueue<? extends E> c) { //判断集合类型是否为PriorityQueue，不是则转到initFromCollection方法 if (c.getClass() == PriorityQueue.class) { this.queue = ensureNonEmpty(c.toArray()); this.size = c.size(); } else { initFromCollection(c); } } //此处我们先大概知道heapify是将数组转化成我们想要的堆。 //通过initElementsFromCollection方法已经将集合转为数组了，为什么还要转成我们想要的堆呢？ //因为在Sorted集合中数组已经是按我们想要的顺序进行排列，而我们传入的该集合并没有可以让其有顺序的排列的功能，所以还需要调用heapify方法将数组元素的顺序做进一步的转化。 private void initFromCollection(Collection<? extends E> c) { initElementsFromCollection(c); heapify(); }
总结一下：如果没有传入比较器，则元素类必须实现了Comparable接口或者在创建队列时传入Comparator对象。如果没有传入队列的长度就使用源码中的默认初始化长度：11。如果传入的是集合：若集合的类型为SortedSet：转为Object类型的数组；是PriorityQueue则直接转化为数组，因为其本身就是Object类型的数组，无需再做转化；以上两种都不是则先将其转化为Object类型的数组，再调用heapify()进行排序。
3.入队
优先队列内部是以堆来实现的，那我们首先来看看堆是如何添加元素的。(以小顶堆为例)
假如有这样一个数组：1，3，9，8，10 接下来将模拟该数组以堆的方式建立
假如想将2添加进去，第一步就是将2先放到数组的最后一位，如图所示
此时2在数组中的下标为5，通过5我们可以计算出其父节点的下标为(5-1)/2 = 2.可以看到2下标对应的数是9。比较后发现子节点的数值小于父节点，不符合小顶堆的定义，所以更换两个数的位置。如图：
继续比较其与其父节点的大小，2<1,符合小顶堆的定义。至此就添加成功了。接下来将对照源码说明。
public boolean add(E e) { return offer(e);//可以看出add()其实也是调用了offer()完成入队操作。 } public boolean offer(E e) { //如果传进来的是null值就抛异常 if (e == null) throw new NullPointerException(); modCount++；//队列操作数+1. int i = size; //如果此时队列已经满了，则调用grow()进行扩容，该方法待会详说 if (i >= queue.length) grow(i + 1); //优先队列并不是按元素添加的顺序排列的，所以不能直接添加到数组的尾部，调用该方法相当于完成刚才添加元素2的操作。 siftUp(i, e); //更新队列长度 size = i + 1; return true; } private void siftUp(int k, E x) { //如果比较器不为空，使用自定义的比较器进行元素的添加 if (comparator != null) siftUpUsingComparator(k, x, queue, comparator); else //比较器为空。其实两者原理相同，我们详说比较器为空的方法。 siftUpComparable(k, x, queue); } //对参数加以说明：k是当前队列的长度(也是新元素添加进来的下标),x是待入队的元素，es是当前队列 private static <T> void siftUpComparable(int k, T x, Object[] es) { Comparable<? super T> key = (Comparable<? super T>) x; while (k > 0) { //通过该表达式得到待添加元素父节点的下标 int parent = (k - 1) >>> 1; Object e = es[parent]; //如果待添加元素的值大于父节点的值，则说明我们找到了新元素待插入的位置，即k，并跳出循环。 if (key.compareTo((T) e) >= 0) break; //如果不是，则将父节点的元素下移，且父节点的下标为待添加元素上移的下标，继续while循环判断当前下标与其父节点的大小。 es[k] = e; k = parent; } //k即为即为我们确定的新节点待插入的位置 es[k] = key; }
其实源码与我们刚才图所示的有点出入，我们发现源码并没有做值得交换，只是一直与其现在所处位置的父节点进行比较，并在满足条件时进行上移，直到找到待插入的位置才将key插入。
上述代码中还有一个方法未提到，grow()。接下来就谈谈优先队列的扩容机制：
private void grow(int minCapacity) { int oldCapacity = queue.length; //可以看到，在调用newLength()这个方法的第三个参数：以旧容量与64的大小做了一个判断：如果旧容量小于64，那么增长因子为2；
若旧容量大于64，那么增长因子就为1.5。
还有一个要说明的是。若传入的minCapacity大于旧容量的2倍，则扩容后的数组的长度为minCapacity。 int newCapacity = ArraysSupport.newLength(oldCapacity, minCapacity - oldCapacity, /* minimum growth */ oldCapacity < 64 ? oldCapacity + 2 : oldCapacity >> 1 /* preferred growth */); queue = Arrays.copyOf(queue, newCapacity); } public static int newLength(int oldLength, int minGrowth, int prefGrowth) { //我们以oldLength=11,minGrowth=1,prefGrowth=13为例 int newLength = Math.max(minGrowth, prefGrowth) + oldLength;//计算得出newLength = 24；即验证了我们刚才所说的增长因子为2：12*2=24。 if (newLength - MAX_ARRAY_LENGTH <= 0) { return newLength; } //当扩容后数组的长度大于MAX_ARRAY_LENGTH则调用hugeLength() return hugeLength(oldLength, minGrowth); }
出队列：
若队列长度为1：返回队顶元素并将队列长度置为0即可。
若队列长度 > 1：队顶元素依然是出队列的元素。不同的是要改变队列元素的位置。
那么问题就来了：如何改变队列元素的位置使其依然是小顶堆呢？
源代码中通过有无比较器调用相对应的方法，但其本质是相同的。
public E poll() { final Object[] es; final E result; //判断队列是否为空 if ((result = (E) ((es = queue)[0])) != null) { modCount++; //队列操作数+1 final int n; //n是当前队列最后一个元素的下标，对应的x就是最后一个元素 final E x = (E) es[(n = --size)]; es[n] = null; 如果n=0：该队列仅有一个元素：x。返回x即可。 if (n > 0) { final Comparator<? super E> cmp; if ((cmp = comparator) == null) siftDownComparable(0, x, es, n); else siftDownUsingComparator(0, x, es, n, cmp); } } return result; }
用图来解释 siftDownComparable()该方法是如何工作的：
要做的工作是：元素 1 出队列，并将队列的长度-1。
保存队列的最后一个元素 x = 10; n = 5：为队列最后一个元素的下标，half = n/2 = 2：为去除下标对应的元素后第一个叶子节点的下标 。
找出队顶元素子节点的最小值：2。并保存其下标：child = （k * 2)+1 / (k * 2)+2 ，这个表达式主要是找到k的子节点的最小值。判断最小值2与10的大小：2 < 10，所以2上浮。若k的子节点都比 10 大，说明k就是10待插入的下标。不用再作比较，跳出循环即可。
上述工作完成后另 k = child，比较 k 与 child的大小：若k大则说明k节点下还有子节点可以用来与 10 做比较，不是则说明 k 就是 10待插入的下标。此处 k = 2 , child = 2：说明找到了1带插入的位置,即k。
private static <T> void siftDownComparable(int k, T x, Object[] es, int n) { // assert n > 0; Comparable<? super T> key = (Comparable<? super T>)x; int half = n >>> 1; // loop while a non-leaf //half是第一个无子节点的节点的下标 while (k < half) { int child = (k << 1) + 1; // assume left child is least Object c = es[child]; int right = child + 1; //找出节点k的子节点中较小的那一个，并将其下标赋给child if (right < n && ((Comparable<? super T>) c).compareTo((T) es[right]) > 0) c = es[child = right]; //若key比较小的那一个还小，则k就是key待插入的下标，并跳出循环 if (key.compareTo((T) c) <= 0) break; //否则将c上浮，并更新待比较节点的位置，直至跳出循环 es[k] = c; k = child; } es[k] = key; }
以上就是我对优先队列源码的分析，不正之处欢迎大家指正。感谢！