ArrayDeque源码解析

问题

（1）什么是双端队列？

（2）ArrayDeque 是怎么实现双端队列的？

（3）ArrayDeque 是线程安全的吗？

（4）ArrayDeque 是有界的吗？

简介

双端队列是一种特殊的队列，它的两端都可以进出元素，故而得名双端队列。
ArrayDeque 是一种以数组方式实现的双端队列，它是非线程安全的。

由其名字可以看出，其是一个由数组实现的双端队列，对比 LinkedList 是由链表实现的双端队列。

继承体系

通过继承体系可以看，ArrayDeque 实现了 Deque 接口，Deque 接口继承自 Queue 接口，它是对 Queue 的一种增强。

public interface Deque<E> extends Queue<E> {
    // 添加元素到队列头
    void addFirst(E e);
    // 添加元素到队列尾
    void addLast(E e);
    // 添加元素到队列头
    boolean offerFirst(E e);
    // 添加元素到队列尾
    boolean offerLast(E e);
    // 从队列头移除元素
    E removeFirst();
    // 从队列尾移除元素
    E removeLast();
    // 从队列头移除元素
    E pollFirst();
    // 从队列尾移除元素
    E pollLast();
    // 查看队列头元素
    E getFirst();
    // 查看队列尾元素
    E getLast();
    // 查看队列头元素
    E peekFirst();
    // 查看队列尾元素
    E peekLast();
    // 从队列头向后遍历移除指定元素
    boolean removeFirstOccurrence(Object o);
    // 从队列尾向前遍历移除指定元素
    boolean removeLastOccurrence(Object o);
    /*
     * 队列中的方法
     */  
    // 添加元素，等于addLast(e)
    boolean add(E e);
     // 添加元素，等于offerLast(e)
    boolean offer(E e);
    // 移除元素，等于removeFirst()
    E remove();
    // 移除元素，等于pollFirst()
    E poll();
    // 查看元素，等于getFirst()
    E element();
    // 查看元素，等于peekFirst()
    E peek();
    /*
     * 栈方法
     */  
    // 入栈，等于addFirst(e)
    void push(E e);
    // 出栈，等于removeFirst()
    E pop();
	/*
     * Collection中的方法
     */  
    // 删除指定元素，等于removeFirstOccurrence(o)
    boolean remove(Object o);
    // 检查是否包含某个元素
    boolean contains(Object o);
    // 元素个数
    public int size();
    // 迭代器
    Iterator<E> iterator();
    // 反向迭代器
    Iterator<E> descendingIterator();
}

Deque 中新增了以下几类方法：

*First，表示从队列头操作元素；
*Last，表示从队列尾操作元素；
push(e)，pop()，以栈的方式操作元素的方法；

Java 里有一个叫做 Stack 的类，却没有叫做 Queue 的类（它是个接口名字），但是 Stack 继承自 Vector，方法都是同步的，一般不使用。

当需要使用栈时，Java 已不推荐使用 Stack，而是推荐使用更高效的 ArrayDeque；既然 Queue 只是一个接口，当需要使用队列时也就首选 ArrayDeque 了（次选是 LinkedList）。

源码解析

属性

    // 存储元素的数组
    transient Object[] elements;
    // 头指针
    transient int head;
    // 尾指针
    transient int tail;
    // 默认最小容量（注意：elements的长度一定是2的次方幂）
    private static final int MIN_INITIAL_CAPACITY = 8;

从属性我们可以看到，ArrayDeque 使用数组存储元素，并使用头尾指针标识队列的头和尾，其最小容量是 8。

ArrayDeque底层是使用数组实现的，而且数组的长度必须是2的整数次幂，这么操作的原因是为了后面位运算好操作。在ArrayDeque当中有两个整形变量head和tail，分别指向右侧的第一个进入队列的数据和左侧第一个进入队列的数据，整个内存布局如下图所示：

其中 tail 指的位置没有数据，head 指的位置存在数据。

构造方法

调用无参构造器时，默认创建一个长度为16的数组。
调用传入初始容量 n 的构造器，当 n 小于 8 时，会初始化一个长度为 8 的一个数组。
当 n 大于等于 8 时，会初始化一个长度为<大于n的最小的2的幂>的数组（比如传入 3 算出来是 8，传入 9 算出来是 16，传入 16 算出来是 32）

    /*          
     * 空参构造器，底层初始化一个长度为16的数组
     */
	public ArrayDeque() {
        elements = new Object[16];
    }

	/*          
	 * 指定元素个数初始化
	 * 传入初始容量，注意最终的容量是大于(没有等于)numElements的最大的2的幂
	 * 然后会创建出来。
	 */
    public ArrayDeque(int numElements) {
        allocateElements(numElements);
    }
	
	/* 
	 * 传入一个集合，将集合c中的元素初始化到数组中
	 * 创建一个长度为<小于等于c.size的最大的2的幂>的数组
	 * 然后将c中的元素添加到elements中。
	 */
    public ArrayDeque(Collection<? extends E> c) {
        allocateElements(c.size());
        addAll(c);
    }

allocateElements()

 	// 构造一个长度为<严格大于numElements的最小的2的幂>的一个数组
	private void allocateElements(int numElements) {
        elements = new Object[calculateSize(numElements)];
   }

	// 返回严格大于numElements的最小的2的幂 (当numElements小于8时，返回8)
    private static int calculateSize(int numElements) {
        // MIN_INITIAL_CAPACITY = 8
        int initialCapacity = MIN_INITIAL_CAPACITY;
        // 当numElements大于等于8时，计算出大于numElements的最小的2的幂
        if (numElements >= initialCapacity) {
            initialCapacity = numElements;
            initialCapacity |= (initialCapacity >>>  1);
            initialCapacity |= (initialCapacity >>>  2);
            initialCapacity |= (initialCapacity >>>  4);
            initialCapacity |= (initialCapacity >>>  8);
            initialCapacity |= (initialCapacity >>> 16);
            initialCapacity++;
			// 条件成立：说明爆int了，需要缩小数据，将initialCapacity无符号右移一位，相当于/2
            if (initialCapacity < 0)   // Too many elements, must back off
                initialCapacity >>>= 1;// Good luck allocating 2 ^ 30 elements
        }
        // 这里如果numElements小于8时，直接返回8
        return initialCapacity;
    }

通过构造方法，我们知道默认初始容量是 16，最小容量是 8。

关于 calculateSize() 方法的图文分析可参考该文章：17张图带你深度剖析 ArrayDeque（JDK双端队列）源码

入队

入队有很多方法，我们这里主要分析两个，addFirst(e) 和 addLast(e)。

addFirst(E, e)

    // 从队头入队
	public void addFirst(E e) {
        // 不允许null元素
        if (e == null)
            throw new NullPointerException();
        /*
         * 将head指针减1并与数组长度减1取模
         * 因为element.length一定是2的幂，2的幂-1的二进制从低位起是一串1，高位都是0
         * 初始时head = 0，0 - 1 = -1 ，-1 & 15 = 15，此时head = 15
         *      下一次 15 - 1 = 14，14 & 15 = 14，此时head = 14
         *      再下一次 14 - 1 = 13，13 & 15 = 13，此时head = 13
         *      ...
         * 这是为了防止数组到头了边界溢出。
         * 最终如果到头了，且数组未满时，就从尾再向前，相当于循环利用数组。
         * 即head指向的是当前队头元素。
         */
        elements[head = (head - 1) & (elements.length - 1)] = e;
        // tail指向的是头元素的下一个位置。判断head == tail即判断数组是否满了，需要扩容。
        if (head == tail)
            // 从方法名可以看出，扩容为原数组长度2倍。
            doubleCapacity();
    }

addLast(E e)

    // 从队尾入队
    public void addLast(E e) {
        // 不允许null元素
        if (e == null)
            throw new NullPointerException();
        // 初始时tail为0，直接入队，此时tail指向的是从队尾入队队列的头元素的下一个位置。
        elements[tail] = e;
        /*
         * head指向的是队头元素的位置
         * tail + 1指向队头的下一个元素，判断是否 == head，即判断数组是否满了。
         * 即是否走扩容的逻辑。
         */
        if ( (tail = (tail + 1) & (elements.length - 1)) == head)
            doubleCapacity();
    }

（1）入队有两种方式，从队列头或者从队列尾；

（2）如果容量不够了，直接扩大为两倍；

（3）通过取模的方式让头尾指针在数组范围内循环；

（4）x & (len - 1) = x % len，使用 & 位运算的方式更快；

扩容

    private void doubleCapacity() {
        // assert:断言，判断head是否等于tail
        // 值为true时，程序从断言语句处继续执行
		// 值为false时，程序从断言语句处停止执行
        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];
        // 将旧数组head之后的元素拷贝到新数组中
        System.arraycopy(elements, p, a, 0, r);
        // 将旧数组下标0到head之间的元素拷贝到新数组中
        System.arraycopy(elements, 0, a, r, p);
        // 赋值为新数组
        elements = a;
        // head指向0，tail指向旧数组长度表示的位置
        head = 0;
        tail = n;
    }

扩容这里迁移元素可能有点绕，请看下面这张图来理解。

出队

出队同样有很多方法，我们主要看两个，pollFirst() 和 pollLast()。

pollFirst()

    // 从队列头出队
    public E pollFirst() {
        int h = head;
        @SuppressWarnings("unchecked")
        // 取队列头元素 (head指向的就是头元素)
        E result = (E) elements[h];
        // 如果队列为空，就返回null
        if (result == null)
            return null;
        // 将队列头置为空
        elements[h] = null;
        // 队列头指针右移一位
        head = (h + 1) & (elements.length - 1);
        // 返回出队的元素
        return result;
    }

pollLast()

    // 从队列尾出队
    public E pollLast() {
        // 尾指针左移一位 因为通过addLast()我们可以知道，tail指向的是头元素的下一个位置
        int t = (tail - 1) & (elements.length - 1);
        @SuppressWarnings("unchecked")
        // 取当前尾指针处元素
        E result = (E) elements[t];
        // 如果队列为空返回null
        if (result == null)
            return null;
        // 将当前尾指针处置为空
        elements[t] = null;
        // tail指向新的尾指针处
        tail = t;
        // 返回出队的元素
        return result;
    }

（1）出队有两种方式，从队列头或者从队列尾；

（2）通过取模的方式让头尾指针在数组范围内循环；

（3）出队之后没有缩容；

小补充

add() 默认在队列尾部插入
remove() 默认从队列头部删除

    public boolean add(E e) {
        addLast(e);
        return true;
    }

	public E remove() {
        return removeFirst();
    }

栈操作

前面我们介绍 Deque 的时候说过，Deque 可以直接作为栈来使用，那么 ArrayDeque 是怎么实现的呢？

    // 入栈
    public void push(E e) {
        addFirst(e);
    }

    // 出栈
    public E pop() {
        // 底层调用的还是pollFirst()
        return removeFirst();
    }