ArrayDeque循环队列的部分源码分析

ArrayDeque是一个以循环数组实现的双向队列。

官方是这么描述的：Deque 接口的大小可变数组的实现。数组双端队列没有容量限制；它们可根据需要增加以支持使用。它们不是线程安全的；在没有外部同步时，它们不支持多个线程的并发访问。禁止 null 元素。此类很可能在用作堆栈时快于 Stack，在用作队列时快于 LinkedList。

- ArrayDeque头

public class ArrayDeque<E> extends AbstractCollection<E>
                    implements Deque<E>, Cloneable, Serializable

上面是ArrayDeque定义信息，我们可以看出，它实现了AbstractCollection。

- 成员变量

 transient Object[] elements; //定义一个数组，下面我们可以了解到，他的初始化操作在构造函数中，初始大小是16.

 transient int head;//头指针，指向队列的头

 transient int tail;//尾指针，指向队列的队尾

 private static final int MIN_INITIAL_CAPACITY = 8;//数组最小容量。

下面我们看一下，构造函数。

- 构造函数1

   public ArrayDeque() {
        elements = new Object[16];//无参数构函，循环数组的默认大小是16.
    }

- 构造函数2

 public ArrayDeque(int numElements) {//这里用户提供了容量
        allocateElements(numElements);//构函调用了这个函数，下面我们                       来分析allocateElements();
    }

 private void allocateElements(int numElements) {
     //先定义一个变量作为数组的最小容量，也就是上面定义变量：最小容量为8，如果用户输入的小于8，直接就用最小容量，来创建数组。
        int initialCapacity = MIN_INITIAL_CAPACITY;
        //如果大于8，则将initialCapacity 变成与其最接近并大于等于其自身的2的n次方幂
        if (numElements >= initialCapacity) {
            initialCapacity = numElements;
            initialCapacity |= (initialCapacity >>>  1);
            initialCapacity |= (initialCapacity >>>  2);
            initialCapacity |= (initialCapacity >>>  4);
            initialCapacity |= (initialCapacity >>>  8);
            initialCapacity |= (initialCapacity >>> 16);
            initialCapacity++;
            //如果数组容量太大溢出，直接赋值为2的30次幂
            //官方的注释：Too many elements, must back off，Good                      luck allocating 2 ^ 30 elements
        if (initialCapacity < 0)   
                initialCapacity >>>= 1;
        }
        elements = new Object[initialCapacity];
    }

我们看一下：
initialCapacity = numElements;
initialCapacity |= (initialCapacity >>> 1);
initialCapacity |= (initialCapacity >>> 2);
initialCapacity |= (initialCapacity >>> 4);
initialCapacity |= (initialCapacity >>> 8);
initialCapacity |= (initialCapacity >>> 16);
initialCapacity++;
假设我们输入的是17，initialCapacity 被赋值为17，17的二进制为10001

• 10001>>>1=1000，10001|1000=11001；
• 11001>>>2 =110，11001|110=11111；
• 11111>>>4=1，11111|1=11111;
• 11111>>>8=0，11111|0=11111;

• 11111>>>16=0，11111|0=11111;

• 最后initialCapacity++，也就是11111+1=100000转化为10进制也就是32。32也确实是大于17最近的2的n次幂。
  这个算法的应用是很高效的，时间复杂度是O（1），要比用其他算法求效率要高。

- 构造函数3

public ArrayDeque(Collection<? extends E> c) {
        allocateElements(c.size());//我们上面已经介绍过了
        addAll(c);//把集合元素放在数组中
    }

-部分成员方法

接下来，我们来看主要的添加操作：这个类中的操作主要有两个，一个从头加，一个是从尾加。

    public void addFirst(E e) {
        if (e == null)
            throw new NullPointerException();//健壮性判断
        elements[head = (head - 1) & (elements.length - 1)] = e;//每次向头添加都是，头指针自减并与数组长度-1进行与运算。
        if (head == tail)
            doubleCapacity();//如果循环数组加满，我们就扩容。
    }

我们来分析 elements[head = (head - 1) & (elements.length - 1)] = e;
由于容量总是2的n次幂，所以总有以下规律
设a是一个整型变量，elements是2的n次幂的整型，那么有
当a=-1时
a&elements-1=elements-1 成立
当0<=a<=elements-1
a&elements-1=a
所以一开始head=0时，就向头中插入元素，实际插入的位置是数组的末尾。

我们在来看下面的doubleCapacity() 扩容方法。

   private void doubleCapacity() {
        assert head == tail;
        int p = head;
        int n = elements.length;
        int r = n - p; // 数组右面的长度
        int newCapacity = n << 1;//新容量是旧容量的2倍
        if (newCapacity < 0)
            throw new IllegalStateException("Sorry, deque too big");
        Object[] a = new Object[newCapacity];
        System.arraycopy(elements, p, a, 0, r);//拷贝数组右边，从head开始，拷贝r个长度，放在新数组从0开始的位置上。
        System.arraycopy(elements, 0, a, r, p);
        //拷贝数组左边，从0开始，拷贝p个长度，放在新数组从r开始的位置上。
        elements = a;
        head = 0;
        tail = n;//head和tail指针重新初始化
    }

我们来看从队尾加的方法

 public void addLast(E e) {
        if (e == null)
            throw new NullPointerException();
        elements[tail] = e;//需要注意的是，在队头插入结点是先走了一位在插入，这里队尾是现在当前位置插入，在“向前”走一位。
        if ( (tail = (tail + 1) & (elements.length - 1)) == head)//如果头尾相遇就扩容，这个算法上面已经介绍过了， 和(elements.length - 1)进行与运算是为了尾指针能够自动循环。
            doubleCapacity();
    }

接下来是删除队头的节点

  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;     //将要poll的节点位置设置为空
        head = (h + 1) & (elements.length - 1);//头指针向后挪一位
        return result;
    }

删除队尾结点

 public E pollLast() {
        int t = (tail - 1) & (elements.length - 1);//因为队尾插入的特点，尾指针现在指向的是尾结点的后一位，所以要tail-1来指向当前的尾结点。
        @SuppressWarnings("unchecked")
        E result = (E) elements[t];
        if (result == null)
            return null;
        elements[t] = null;//将取出来的尾结点的位置，置空。
        tail = t;
        return result;
    }

//只取头结点而不删除
@SuppressWarnings("unchecked")
    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)];
    }