环境：JDK1.8
Queue和Dequeue实现类概要
Queue集合的实现类之ArrayDeque
ArrayDeque是一个基于可扩容可循环使用的数组结构实现的双端队列，它可以用作双端队列、队列、栈。
1.ArrayDeque集合的重要变量
// 存储双端队列中的数据对象
transient Object[] elements;
// 指向队列头部
transient int head;
// 指向队列尾部的下一个索引位
transient int tail;
// 双端队列的容量下限
private static final int MIN_INITIAL_CAPACITY = 8;
2.ArrayDeque集合的初始化过程
// 初始化一个长度为16的数组
public ArrayDeque() {
elements = new Object[16];
}
// 初始化的数组容量大小保证为2的多少次方
public ArrayDeque(int numElements) {
allocateElements(numElements);
}
// 保证数组容量大小为2的多少次方
// 例如形参为16，则容量为32
// 形参为2^16 + 1,则容量为2^17
private static int calculateSize(int numElements) {
int initialCapacity = MIN_INITIAL_CAPACITY;
// Find the best power of two to hold elements.
// Tests "<=" because arrays aren't kept full.
// 比8大
if (numElements >= initialCapacity) {
initialCapacity = numElements;
initialCapacity |= (initialCapacity >>> 1);
initialCapacity |= (initialCapacity >>> 2);
initialCapacity |= (initialCapacity >>> 4);
initialCapacity |= (initialCapacity >>> 8);
initialCapacity |= (initialCapacity >>> 16);
initialCapacity++;
if (initialCapacity < 0) // Too many elements, must back off
initialCapacity >>>= 1;// Good luck allocating 2 ^ 30 elements
}
// 比8小
return initialCapacity;
}
3.ArrayDeque集合的添加操作
- addFirst(E)：在双端队列头部添加对象，在head == tail时进行扩容
// elements.length保证为2的多少次方
public void addFirst(E e) {
// 添加的对象不能为null
if (e == null)
throw new NullPointerException();
// 如果head-1大于等于0，则head的值更新为head - 1(elements.length - 1的补码全为000...111...1)
// 如果head-1小于0，则补码全为1，head的值更新为elements.length - 1
elements[head = (head - 1) & (elements.length - 1)] = e;
// 扩容
if (head == tail)
doubleCapacity();
}
- addLast(E)：在双端队列尾部添加对象，在head == tail时进行扩容
public void addLast(E e) {
if (e == null)
throw new NullPointerException();
elements[tail] = e;
// 如果tail + 1等于elements.length，则tail更新为0
// 如果tail + 1小于elements.length，则tail更新为tail + 1
if ( (tail = (tail + 1) & (elements.length - 1)) == head)
doubleCapacity();
}
4.ArrayDeque集合的扩容操作
- ArrayDeque集合按照2倍进行扩容。扩容后为了保证从头节点到尾节点可以形成一个有连续数据对象的循环数组，需要对head、tail进行修正。
private void doubleCapacity() {
assert head == tail;
int p = head;
int n = elements.length;
int r = n - p; // number of elements to the right of p
// 扩容至原来的容量的2倍
int newCapacity = n << 1;
if (newCapacity < 0)
throw new IllegalStateException("Sorry, deque too big");
Object[] a = new Object[newCapacity];
// 将head指针指向的元素以及后面的元素拷贝到目标数组中
System.arraycopy(elements, p, a, 0, r);
// 将head指针前面的元素拷贝到目标数组中
System.arraycopy(elements, 0, a, r, p);
elements = a;
// 修正队头和队尾的位置
head = 0;
tail = n;
}
5.ArrayDequeue的特点
- ArrayDeque是线程不安全的，不能在多线程环境下使用。
- ArrayDeque既有队列、双端队列的特点，也有栈的操作特点。
Queue集合的实现类之PriorityQueue
一种基于数组形式的小顶堆结构的优先级队列，这个优先级由程序员自定义，定义的方式有两种，其一是使用对象的自然排序，其二是使用定制排序。（这个数组是一颗完全二叉树的降维表达）。
1.PriorityQueue集合中重要的变量
// 队列内部数组的默认容量
private static final int DEFAULT_INITIAL_CAPACITY = 11;
// 存储队列中的对象的数组
transient Object[] queue;
// 队列中的对象数量
private int size = 0;
// 比较器
private final Comparator<? super E> comparator;
// 队列中被修改的次数
transient int modCount = 0;
2.PriorityQueue集合中重要的初始化方法
- 无参构造方法：创建一个包含默认容量为11的优先级队列。在初始化队列时不指定比较器，则队列中存储的对象需要自定义比较规则（即实现Comparable接口）
public PriorityQueue() {
this(DEFAULT_INITIAL_CAPACITY, null);
}
- 根据指定容量和指定的比较器进行队列的初始化
public PriorityQueue(int initialCapacity,
Comparator<? super E> comparator) {
// Note: This restriction of at least one is not actually needed,
// but continues for 1.5 compatibility
if (initialCapacity < 1)
throw new IllegalArgumentException();
this.queue = new Object[initialCapacity];
this.comparator = comparator;
}
- 根据其他集合进行初始化队列
@SuppressWarnings("unchecked")
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<?>) {
PriorityQueue<? extends E> pq = (PriorityQueue<? extends E>) c;
this.comparator = (Comparator<? super E>) pq.comparator();
initFromPriorityQueue(pq);
}
else {
this.comparator = null;
initFromCollection(c);
}
}
private void initFromPriorityQueue(PriorityQueue<? extends E> c) {
if (c.getClass() == PriorityQueue.class) {
this.queue = c.toArray();
this.size = c.size();
} else {
initFromCollection(c);
}
}
private void initElementsFromCollection(Collection<? extends E> c) {
Object[] a = c.toArray();
// If c.toArray incorrectly doesn't return Object[], copy it.
if (a.getClass() != Object[].class)
a = Arrays.copyOf(a, a.length, Object[].class);
int len = a.length;
if (len == 1 || this.comparator != null)
for (int i = 0; i < len; i++)
if (a[i] == null)
throw new NullPointerException();
this.queue = a;
this.size = a.length;
}
private void initFromCollection(Collection<? extends E> c) {
initElementsFromCollection(c);
// 进行堆降序操作，保持小顶堆的结构
heapify();
}
3.堆的升序和降序操作
- 堆的升序：在向队列内部添加对象后，队列会验证完全二叉树（在队列内部降维为一个数组）是否还是一个小顶堆结构，如果不是，则会调整新添加的数据对象的索引位置。这个过程叫做堆的升序。从下到上
// 升序操作
// k为x的理想索引位，x为待添加的对象
private void siftUp(int k, E x) {
// 使用定制排序
if (comparator != null)
siftUpUsingComparator(k, x);
// 使用自然排序
else
siftUpComparable(k, x);
}
@SuppressWarnings("unchecked")
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;
}
// k为符合要求的索引位置
queue[k] = key;
}
@SuppressWarnings("unchecked")
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;
}
- 堆的降序：当从队列中移除数据对象时，会始终移除完全二叉树根节点上的数据对象（即数组中索引为0的数据对象），然后将最后一个叶子节点上的数据对象替换到根节点上，之后队列判断当前的完全二叉树能否保持堆结构，如果不能则从根节点开始进行降序操作，使得完全二叉树重新恢复成堆结构。从上到下
// 降序操作
// k为开始降序操作的索引位置，x为替换到根节点的最后一个叶子节点
private void siftDown(int k, E x) {
if (comparator != null)
siftDownUsingComparator(k, x);
else
siftDownComparable(k, x);
}
@SuppressWarnings("unchecked")
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) {
// child存储左右孩子节点中较小的那个，假设为左孩子
int child = (k << 1) + 1; // assume left child is least
Object c = queue[child];
// 右孩子
int right = child + 1;
// right < size判断右孩子是否存在
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;
}
@SuppressWarnings("unchecked")
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.PriorityQueue集合的扩容操作
// minCapacity为期望扩容后的队列最小容量
private void grow(int minCapacity) {
int oldCapacity = queue.length;
// Double size if small; else grow by 50%
int newCapacity = oldCapacity + ((oldCapacity < 64) ?
(oldCapacity + 2) :
(oldCapacity >> 1));
// overflow-conscious code
// 容量上限
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
queue = Arrays.copyOf(queue, newCapacity);
}
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
5.PriorityQueue集合的添加操作
public boolean offer(E e) {
if (e == null)
throw new NullPointerException();
modCount++;
int i = size;
// 容量已满，需要扩容
if (i >= queue.length)
grow(i + 1);
// 更新队列的size
size = i + 1;
// 队列就一个数据对象，不需要进行堆的升序操作
if (i == 0)
queue[0] = e;
else
// 堆的升序操作，以保持堆的结构
siftUp(i, e);
return true;
}
6.PriorityQueue集合的移除操作
- 移除队头的元素（索引位置为0的数据对象）
@SuppressWarnings("unchecked")
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;
}
- 移除任意索引位置的数据对象
@SuppressWarnings("unchecked")
private E removeAt(int i) {
// assert i >= 0 && i < size;
modCount++;
int s = --size;
// 移除最后一个对象
if (s == i) // removed last element
queue[i] = null;
else {
// 最后一个叶子节点
E moved = (E) queue[s];
queue[s] = null;
// 降序操作
siftDown(i, moved);
// 无法进行降序操作
if (queue[i] == moved) {
// 进行升序操作
siftUp(i, moved);
// 已进行升序操作
if (queue[i] != moved)
return moved;
}
}
return null;
}
7.小顶堆的修复性排序
在使用其他集合初始化优先级队列时，就会进行小顶堆的修复性排序。
private void initFromCollection(Collection<? extends E> c) {
initElementsFromCollection(c);
heapify();
}
@SuppressWarnings("unchecked")
private void heapify() {
// 从最后一个非叶子结点开始进行降序操作
for (int i = (size >>> 1) - 1; i >= 0; i--)
siftDown(i, (E) queue[i]);
}
