PriorityQueue源码解析

 1     // 默认初始化大小 
 2     privatestaticfinalintDEFAULT_INITIAL_CAPACITY = 11;
 3 
 4     // 用数组实现的二叉堆，下面的英文注释确认了我们前面的说法。 
 5     /**
 6      * Priority queue represented as a balanced binary heap: the two
 7      * children of queue[n] are queue[2*n+1] and queue[2*(n+1)].  The
 8      * priority queue is ordered by comparator, or by the elements‘
 9      * natural ordering, if comparator is null: For each node n in the
10      * heap and each descendant d of n, n <= d.  The element with the
11      * lowest value is in queue[0], assuming the queue is nonempty.
12      */
13     private transient Object[] queue ;
14 
15     // 队列的元素数量
16     private int size = 0;
17 
18     // 比较器
19     private final Comparator<? super E> comparator;
20 
21     // 修改版本
22     private transient int modCount = 0;

 1     /**
 2      * 数组扩容
 3      */
 4     private void grow(int minCapacity) {
 5         // 如果最小需要的容量大小minCapacity小于0，则说明此时已经超出int的范围，则抛出OutOfMemoryError异常
 6         if (minCapacity < 0) // overflow
 7             throw new OutOfMemoryError();
 8         // 记录当前队列的长度
 9         int oldCapacity = queue .length;
10         // Double size if small; else grow by 50%
11         // 如果当前队列长度小于64则扩容2倍，否则扩容1.5倍
12         int newCapacity = ((oldCapacity < 64)?
13                            ((oldCapacity + 1) * 2):
14                            ((oldCapacity / 2) * 3));
15         // 如果扩容后newCapacity超出int的范围，则将newCapacity赋值为Integer.Max_VALUE
16         if (newCapacity < 0) // overflow
17             newCapacity = Integer. MAX_VALUE;
18         // 如果扩容后，newCapacity小于最小需要的容量大小minCapacity，则按找minCapacity长度进行扩容
19         if (newCapacity < minCapacity)
20             newCapacity = minCapacity;
21         // 数组copy，进行扩容
22         queue = Arrays.copyOf( queue, newCapacity);
23     }

 1     /**
 2      * 删除并返回队头的元素，如果队列为空则抛出NoSuchElementException异常（该方法在AbstractQueue中）
 3      */
 4     public E remove() {
 5         E x = poll();
 6         if (x != null)
 7             return x;
 8         else
 9             throw new NoSuchElementException();
10     }
11 
12     /**
13      * 删除并返回队头的元素，如果队列为空则返回null
14      */
15    public E poll() {
16         // 队列为空，返回null
17         if (size == 0)
18             return null;
19         // 队列元素个数-1
20         int s = --size ;
21         // 修改版本+1
22         modCount++;
23         // 队头的元素
24         E result = (E) queue[0];
25         // 队尾的元素
26         E x = (E) queue[s];
27         // 先将队尾赋值为null
28         queue[s] = null;
29         // 如果队列中不止队尾一个元素，则调用siftDown方法进行"下移"操作
30         if (s != 0)
31             siftDown(0, x);
32         return result;
33     }
34 
35     /**
36      * 上移，x表示队尾的元素，k表示被删除元素在数组的位置
37      */
38     private void siftDown(int k, E x) {
39         // 如果比较器comparator不为空，则调用siftDownUsingComparator方法进行下移操作
40         if (comparator != null)
41             siftDownUsingComparator(k, x);
42         // 比较器comparator为空，则调用siftDownComparable方法进行下移操作
43         else
44             siftDownComparable(k, x);
45     }
46 
47     private void siftDownComparable(int k, E x) {
48         // 比较器comparator为空，需要插入的元素实现Comparable接口，用于比较大小
49         Comparable<? super E> key = (Comparable<? super E>)x;
50         // 通过size/2找到一个没有叶子节点的元素
51         int half = size >>> 1;        // loop while a non-leaf
52         // 比较位置k和half，如果k小于half，则k位置的元素就不是叶子节点
53         while (k < half) {
54              // 找到根元素的左孩子的位置[2n+1]
55             int child = (k << 1) + 1; // assume left child is least
56              // 左孩子的元素
57             Object c = queue[child];
58              // 找到根元素的右孩子的位置[2(n+1)]
59             int right = child + 1;
60             // 如果左孩子大于右孩子，则将c复制为右孩子的值，这里也就是找出左右孩子哪个最小
61             if (right < size &&
62                 ((Comparable<? super E>) c).compareTo((E) queue [right]) > 0)
63                 c = queue[child = right];
64             // 如果队尾元素比根元素孩子都要小，则不需"下移"，结束
65             if (key.compareTo((E) c) <= 0)
66                 break; 
67             // 队尾元素比根元素孩子都大，则需要"下移"
68             // 交换跟元素和孩子c的位置
69             queue[k] = c;
70             // 将根元素位置k指向最小孩子的位置，进入下层循环
71             k = child;
72         }
73         // 找到队尾元素x的合适位置k之后进行赋值
74         queue[k] = key;
75     }
76 
77     // 这个方法和上面的操作一样，不多说了
78     private void siftDownUsingComparator(int k, E x) {
79         int half = size >>> 1;
80         while (k < half) {
81             int child = (k << 1) + 1;
82             Object c = queue[child];
83             int right = child + 1;
84             if (right < size &&
85                 comparator.compare((E) c, (E) queue [right]) > 0)
86                 c = queue[child = right];
87             if (comparator .compare(x, (E) c) <= 0)
88                 break;
89             queue[k] = c;
90             k = child;
91         }
92         queue[k] = x;
93     }

1     /**
2      * Establishes the heap invariant (described above) in the entire tree,
3      * assuming nothing about the order of the elements prior to the call.
4      */
5     private void heapify() {
6         for (int i = (size >>> 1) - 1; i >= 0; i--)
7             siftDown(i, (E) queue[i]);
8     }

1 private void heapify() {
2         for (int i = (size >>> 1) - 1; i >= 0; i--)
3             siftDown(i, (E) queue[i]);
4     }