ArrayDeque 是双端队列的动态数组实现，可以当作栈和队列来使用。作为栈时，它的效率比 Stack 更高，作为队列时，效率比 LinkedList 更高。ArrayDeque 大部分操作的时间复杂度都是 O(1)。本文将介绍 ArrayDeque 的核心 API 以及其内部实现的算法。
1. 数据结构
ArrayDeque 的数据结构非常简单，包含一个用于存储数据的 Object 数组和两个分别指向队列头和尾的索引。
transient Object[] elements; // non-private to simplify nested class access
transient int head;
transient int tail;
2. 构造方法
ArrayDeque 有 3 个构造方法。
2.1 ArrayDeque()
ArrayDeque() 方法很简单，仅仅是创建了一个长度为 16 的数组 elements。即 ArrayDeque 的容量为 16。
public ArrayDeque() {
elements = new Object[16];
}
2.2 ArrayDeque(int numElements)
此方法传入一个整数 numElements，elements 数组的长度取决于参数 numElements，但 elemenets 的长度不是直接取 numElements，而是通过 calculateSize(int numElements) 计算之后的值。
public ArrayDeque(int numElements) {
allocateElements(numElements);
}
private void allocateElements(int numElements) {
elements = new Object[calculateSize(numElements)];
}
calculateSize(int) 是一个静态工具方法，传入一个整数 numElements，返回一个恰好大于 numElements 且为 2 的整数次方的值。注意是大于，例如：输入 4，输出的为 8。这里的算法很巧妙，先通过 5 次位操作将 numElements 最高位左侧的二进制位全部置为 1，再加 1 得到返回值。
事实上 elements 数组在 ArrayDeque 的整个生命周期中长度都为 2 的整数次方。
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.
if (numElements >= initialCapacity) {
initialCapacity = numElements; // 这里的位操作关注 numElements 的最高位即可
initialCapacity |= (initialCapacity >>> 1);
initialCapacity |= (initialCapacity >>> 2);
initialCapacity |= (initialCapacity >>> 4);
initialCapacity |= (initialCapacity >>> 8);
initialCapacity |= (initialCapacity >>> 16); // 最高位左侧的二进制位已经全部为 1
initialCapacity++; // 得到一个大于 numElements 且恰好为 2 的整数次幂的数
if (initialCapacity < 0) // 检查是否溢出
initialCapacity >>>= 1;// Good luck allocating 2 ^ 30 elements
}
return initialCapacity;
}
2.3 ArrayDeque(Collection<? extends E> c)
此方法可以传入一个集合，集合中的元素会按照集合中元素的迭代顺序添加到 ArrayDeque 的尾部。调用的为 addLast(e) 方法。
public ArrayDeque(Collection<? extends E> c) {
allocateElements(c.size());
addAll(c);
}
3. 核心 API
ArrayDeque 的 API 是围绕如何在一个动态循环数组进行的一系列操作展开。动态体现在 ArrayDeque 的容量是可以动态扩展的，循环体现在 elements 数组在逻辑上首尾相连接的（物理上 elements 是一个数组，头是 0 ，尾是 elements.length-1）。一系列操作指的是双端队列的操作。
下面通过绘制 ArrayDeque 内部存储结构的方式描述其核心 API 和算法。
3.1 实例化
ArrayDeque<Character> deque= new ArrayDeque();
实例化时 head 和 tail 指针均指向了索引 0 位置。head 总是从右往左循环移动，tail 总是从左往右循环移动。头部添加的下一个元素总是存放在 head 下一个移向的索引位置，尾部添加的下一个元素总是存放在当前 tail 所在的位置。
3.2 尾部添加 addLast(e)
deque.addLast('A');
addLast(e) 方法往双端队列的尾部添加元素，将元素放入 elements[tail]，tail 往右移动一个位置。如果已经 tail 超出了索引范围，则指向 0 。循环利用数组。需要注意的是 ArrayDeque 不能存放 null 元素，不过 Deque 的另一实现 LinkedList 却可以。
JDK 源码使用了高效的位操作实现了这个逻辑。
public void addLast(E e) {
if (e == null) // ArrayDeque 不能存放元素 null
throw new NullPointerException();
elements[tail] = e;
// 因为 elements.length 总是 2 的整数次方，所以 elements.length - 1 所有二进制位均为 1，
// 若 tail+1 < elements.length，则 (tail + 1) & (elements.length - 1) 结果即为 tail+1；
// 若 tail+1 == elements.length，表示下标越界，则 (tail + 1) & (elements.length - 1) 值为 0
// 这里可以解释为什么长度要设置为 2 的整数次方，目的是为了能够高效地进行位操作
// 后面还判断了是否等于 head，相等则表示 elements 数组放满了，此时触发扩容
if ( (tail = (tail + 1) & (elements.length - 1)) == head)
doubleCapacity(); // this.elements 数组长度扩容为原来的两倍
}
3.3 头部添加 addFirst(e)
deque.addFirst('B');
与尾部添加类似，不过移动的是 head 指针，head 指针从往左循环移动 1 个位置，放入元素 elements[head]（移动指针和放入元素的顺序与 addLast() 相反）。与 addLast(e) 类似，源码中同样使用了高效的位操作来进行移动，进行了扩容判断。
3.4 获取头部元素 getFirst() / peekFirst() 和获取尾部元素 getLast() / peekLast()
deque.getFirst(); // 返回 B
deque.getLast(); // 返回 B
deque.peekFirst(); // 返回 A
deque.peekLast(); // 返回 A
从前面尾部添加元素可知，双端队列中有元素的前提下，head 总是指向刚刚往双端队列头部添加的元素的位置，tail 总是指向存放下一个往双端队列添加元素的位置。因此，getFirst() / peekFirst() 返回的是 head 位置的元素，而 getLast() / peekLast() 返回的是上一次 tail 所在元素的位置。
其中 getXXX() 会对获取的值进行判断，若为空，则抛出 NoSuchElementException。前面提到，ArrayDeque 不能存放 null 元素，因此值为空的另一层意思是这个 ArrayDeque 没有存放元素。而 peekXXX() 不会对返回的值进行判断，若获取到 null 则表示这个双端队列中没有元素。可以根据需求来选择相应的 API。
public E getFirst() {
@SuppressWarnings("unchecked")
E result = (E) elements[head];
if (result == null)
throw new NoSuchElementException();
return result;
}
/**
* @throws NoSuchElementException {@inheritDoc}
*/
public E getLast() {
@SuppressWarnings("unchecked")
E result = (E) elements[(tail - 1) & (elements.length - 1)];
if (result == null)
throw new NoSuchElementException();
return result;
}
public E peekFirst() {
// elements[head] is null if deque empty
return (E) elements[head];
}
@SuppressWarnings("unchecked")
public E peekLast() {
return (E) elements[(tail - 1) & (elements.length - 1)];
}
双端队列中还有若干 API 与上面提到的 API 等价，例如：peek() 与 peekFirst()。更多说明可以参考这篇：Java 双端队列接口 Deque。
3.5 移除元素 removeFirst() / pollFirst() 和 removeLast() / pollLast()
上面两组 API 中，removeFirst() 调用了 pollFirst()，removeLast() 调用了 pollLast()，只是增加了返回值为空时抛出异常的内容。
与添加元素相反，移除元素时，pollFirst() 先获取当前元素，然后移动 head 指针往右循环移动 1 个位置；pollLast() 则是先向左循环移动 1 个位置，再获取元素。这里需要注意，head 指针和 tail 指针在 ArrayDeque 有元素的时候才移动，没有元素的时候不会移动。
public E pollFirst() {
int h = head;
@SuppressWarnings("unchecked")
E result = (E) elements[h];
// Element is null if deque empty
if (result == null) // 返回值 null，不移动 head
return null;
elements[h] = null; // 这一句看起来是多余的，但它的目的是让数组 elements 不再引用移除的对象，这样 GC 就能够将对象回收了。
head = (h + 1) & (elements.length - 1); // head 循环右移 1 个位置
return result;
}
deque.pollLast(); // 返回 'A'，tail 往左循环移动 1 个位置，head 不动
deque.pollLast(); // 返回 'B'，tail 往左循环移动 1 个位置，head 不动
deque.pollFirst(); // 返回 null, tail 和 head 均不动
3.6 扩容
不断调用 addFirst(e) 和 addLast(e) 往里面增加元素，当元素增加到 elements 数组存放不下（即双端队列有元素的情况下 head == tail） 时，ArrayDeque 的容量会自动增加 1 倍。
deque.addLast('A');
deque.addLast('B');
...
deque.addLast('M');
elements 数组达到如下状态，此时还差 1 个元素就满了。
再往里添加一个元素。
deque.addFirst('L');
调用 deque.add('L') 时，元素 'L' 先放入到数组中，tail 往右循环移动 1 个位置。然后进行判断，发现 tail 等于 head，触发扩容。扩容过程在 doubleCapacity() 方法中。
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
int newCapacity = n << 1;
if (newCapacity < 0) // 整数溢出了
throw new IllegalStateException("Sorry, deque too big");
Object[] a = new Object[newCapacity];
System.arraycopy(elements, p, a, 0, r); // p=head 以及其右边部分先放到新数组左侧
System.arraycopy(elements, 0, a, r, p); // p=head 左边部分尾随。
elements = a;
head = 0;
tail = n;
}
4. 小结
ArrayDeque 在不考虑扩容的情况下，ArrayDeque 头部和尾部操作都仅仅是移动一下索引，效率极高，时间复杂度为 O(1)。
ArrayDeque 的实现中没有线程同步操作，因此 ArrayDeque 是非线程安全的，并发访问一个 ArrayDeque 可能导致错误。
ArrayDeque 存储结构是一个 Object 数组，数组的长度总是 2 的整数次方，这是 ArrayDeque 某些代码能够进行位操作的基础。