Jdk1.8 Collections Framework源码解析(3)-ArrayDeque

表、栈和队列是三种基本的数据结构，前面总结的ArrayList和LinkedList可以作为任意一种数据结构来使用，当然由于实现方式的不同，操作的效率也会不同。 这篇要看一下java.util.ArrayDeque。从命名上看，它是一个由数组实现的双端队列。还是先看一下它实现了哪些接口。

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

在看看它的类注释，作者是 大名鼎鼎的 Doug Lea， 大师级的人物，鄙人只能膜拜。上面balbala , biu biu biu ...... 的一大窜，大体是说，java.util.ArrayDeque是Deque接口的动态数组实现，容量会按需扩展，线程不安全。作为栈使用比java.util.Stack快，作为队列使用比java.util.LinkedList快。大多数的操作消耗常数时间。主要特性就是这些。

在看源码的时候，还是老规矩，如果是你来做的话，你会如何来实现呢？首先，按照注释的来，肯定是要有个数组来保存数据啦，没啥好说的。既然是双端的队列，必然有一个前，一个后的指针分别指向首尾。既然是一个数组，那么优势就是在查找上，指针移动的速度就会很快，可以快速的查找到元素的位置。整体的想法大概就是这样。 那么接下来，我们来看看java.util.ArrayDeque的源码吧。具体的源码的实现。

    /**
     * The array in which the elements of the deque are stored.
     * The capacity of the deque is the length of this array, which is
     * always a power of two. The array is never allowed to become
     * full, except transiently within an addX method where it is
     * resized (see doubleCapacity) immediately upon becoming full,
     * thus avoiding head and tail wrapping around to equal each
     * other.  We also guarantee that all array cells not holding
     * deque elements are always null.
     */
    private transient E[] elements;

    /**
     * The index of the element at the head of the deque (which is the
     * element that would be removed by remove() or pop()); or an
     * arbitrary number equal to tail if the deque is empty.
     */
    private transient int head;

    /**
     * The index at which the next element would be added to the tail
     * of the deque (via addLast(E), add(E), or push(E)).
     */
    private transient int tail;

    /**
     * The minimum capacity that we'll use for a newly created deque.
     * Must be a power of 2.
     */
    private static final int MIN_INITIAL_CAPACITY = 8;

可以看到，基本上是这样。最后一个常量表示初始化的最小容量，注释说明这个值必须是2的幂，这是为什么？？, 源码注释是这样说的，不知道为啥， 先记住这个问题，继续往下看。

    /**
     * Constructs an empty array deque with an initial capacity
     * sufficient to hold 16 elements.
     */
    public ArrayDeque() {
        elements = (E[]) new Object[16];
    }

    /**
     * Constructs an empty array deque with an initial capacity
     * sufficient to hold the specified number of elements.
     *
     * @param numElements  lower bound on initial capacity of the deque
     */
    public ArrayDeque(int numElements) {
        allocateElements(numElements);
    }

    /**
     * Constructs a deque containing the elements of the specified
     * collection, in the order they are returned by the collection's
     * iterator.  (The first element returned by the collection's
     * iterator becomes the first element, or <i>front</i> of the
     * deque.)
     *
     * @param c the collection whose elements are to be placed into the deque
     * @throws NullPointerException if the specified collection is null
     */
    public ArrayDeque(Collection<? extends E> c) {
        allocateElements(c.size());
        addAll(c);
    }

关注一些注释，一共有3个构造方法。无参的构造方法会创建长度为16的内部数组。接受一个集合的构造方法不用多说了，看一下接受“元素数量”的构造方法，里面会调一个分配内部数组空间的方法。

    /**
     * Allocate empty array to hold the given number of elements.
     *
     * @param numElements  the number of elements to hold
     */
    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 = (E[]) new Object[initialCapacity];
    }

这个方法是根据给定numElements来进行内部数组空间的分配。这里有一个前提，容量必须是2的幂，尽管现在还不知道为什么必须是2的幂，但先往下看。可以看到如果numElements小于最小容量8的话，就会按最小容量来分配数组空间。如果大于等于8，会到一个条件语句中做一些操作，看下这些操作是干嘛的。我们知道如果一个2进制数是2的幂，那么它的特点就是只有一位是1。

2^0 = 1  
2^1 = 10  
2^n = 10000...(n个0)  

2^1 = 1 + 1  
2^3 = 111 + 1  
2^n = 111...(n个1) + 1 

转载于:https://my.oschina.net/u/1187675/blog/1527193