ArrayDeque

原文见Java 容器源码分析之 Deque 与 ArrayDeque。

概述

ArrayDeque是Deque接口的一个实现，使用了可变数组，所以没有容量上的限制。同时，ArrayDeque是线程不安全的，在没有外部同步的情况下，不能再多线程环境下使用。ArrayDeque是Deque的实现类，可以作为栈来使用，效率高于Stack；也可以作为队列来使用，效率高于LinkedList。需要注意的是，ArrayDeque不支持null值。

结构

//用数组存储元素
transient Object[] elements; // non-private to simplify nested class access
//头部元素的索引
transient int head;
//尾部下一个将要被加入的元素的索引
transient int tail;
//最小容量，必须为2的幂次方
private static final int MIN_INITIAL_CAPACITY = 8;

在ArrayDeque底层使用了数组来存储数据，同时用两个int值head和tail来表示头部和尾部。不过需要注意的是tail并不是尾部元素的索引，而是尾部元素的下一位，即下一个将要被加入的元素的索引。

初始化

ArrayDeque有三个构造函数来初始化，除了无参的构造函数使用了默认容量，其它两个构造函数会通过allocateElements来计算初始容量。

public ArrayDeque() {
    elements = new Object[16];
}

public ArrayDeque(int numElements) {
    allocateElements(numElements);
}

public ArrayDeque(Collection<? extends E> c) {
    allocateElements(c.size());
    addAll(c);
}

ArrayDeque 对数组的大小(即队列的容量)有特殊的要求，必须是 2^n。我们来看一下allocateElements方法。

private void allocateElements(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;
        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
    }
    elements = new Object[initialCapacity];
}

这里的实现很有意思，对于一个小于2^30的值，经过五次右移和位或操作后，可以得到一个2^k - 1的值。最后再将这个值+1，得到2^k。通过这个方法，可以将一个任意的初始值转化为2^n的值，不过有一点不足在于，如果本身传进来的值就是2^n的值，那么经过转化会变成2^(n+1)，所以我们在不用刻意去传入2^n的值。还有一点在于，如果传入的值大于等于2^30，那么经过转化会变成负值，即< 0，此时会把初始值设置为2^30，即最大的容量只有2^30。

添加元素

向末尾添加元素

public void addLast(E e) {
    if (e == null)
        throw new NullPointerException();
    //tail 中保存的是即将加入末尾的元素的索引
    elements[tail] = e;
    //tail 向后移动一位
    //把数组当作环形的，越界后到0索引
    if ( (tail = (tail + 1) & (elements.length - 1)) == head)
        //tail 和 head相遇，空间用尽，需要扩容
        doubleCapacity();
}

在ArrayDeque中，数组是作为环形来使用的，正常情况下在末尾添加元素后，tail=tail+1是要判断是否越界，如果越界，会变为从索引0开始。参考如下图片，当H添加到索引7后，tail值会+1,此时tail=8，但是越界了，所以应该将tail设置为0。

环形数组

但是为什么这里并没有判断越界呢？关键在于(tail = (tail + 1) & (elements.length - 1)) == head这段代码。这段代码可以拆分为tail = (tail + 1) & (elements.length - 1)和tail == head，这样会比较清晰，前一段代码是为了获取正确的tail索引值，后一段代码是为了判断数组是否满了。之前要求数组的大小必须为2^n值，就是为了能够不通过条件判断，直接使用位操作在环形数组中获取下一个正确的索引值。

我们验证一下tail = (tail + 1) & (elements.length - 1)的正确性：

length = 2^n，二进制表示为: 第 n 位为1，低位 (n-1位) 全为0
length - 1 = 2^n-1，二进制表示为：低位(n-1位)全为1

如果 tail + 1 <= length - 1，则位与后低 (n-1) 位保持不变，高位全为0
如果 tail + 1 = length，则位与后低 n 全为0，高位也全为0，结果为 0

所以当tail+1 <= length - 1，此时数组并没有越界，(tail + 1) & (elements.length - 1)后得到的还是tail+1。如果tail + 1 = length，此时数组越界了，(tail + 1) & (elements.length - 1)后得到0。

所以通过(tail + 1) & (elements.length - 1)可以跳过条件判断在环形数组中获取正确的索引值，然后再判断新的tail是否等于head，如果结果为true，那么数组已经满了，需要扩容，即doubleCapacity()。

向头部添加元素

public void addFirst(E e) {
    if (e == null) //不支持值为null的元素
        throw new NullPointerException();
    elements[head = (head - 1) & (elements.length - 1)] = e;
    if (head == tail)
        doubleCapacity();
}

其实向头部添加元素和向尾部添加元素原理是相同的，都是通过位操作高效获取新的索引值。

扩容

无论是从头部还是从尾部添加元素，都会判断tail==head，如果两个索引相遇，说明数组空间已满，需要扩容操作。见下图：

数组扩容

private void doubleCapacity() {
    assert head == tail; //扩容时头部索引和尾部索引肯定相等
    int p = head;
    int n = elements.length;
    //头部索引到数组末端(length-1处)共有多少元素
    int r = n - p; // number of elements to the right of p
    //容量翻倍，相当于 2 * n
    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);
    //复制其余元素
    System.arraycopy(elements, 0, a, r, p);
    elements = a;
    //重置头尾索引
    head = 0;
    tail = n;
}

移除元素

ArrayDeque支持从头尾两端移除元素，remove方法是通过poll来实现的。因为是基于数组的，在了解了环的原理后这段代码就比较容易理解了。

public E pollFirst() {
    int h = head;
    @SuppressWarnings("unchecked")
    E result = (E) elements[h];
    // Element is null if deque empty
    if (result == null)
        return null;
    elements[h] = null;     // Must null out slot
    head = (h + 1) & (elements.length - 1);
    return result;
}

public E pollLast() {
    int t = (tail - 1) & (elements.length - 1);
    @SuppressWarnings("unchecked")
    E result = (E) elements[t];
    if (result == null)
        return null;
    elements[t] = null;
    tail = t;
    return result;
}