JDK之ArrayDeque源码解析

刚入java不久的程序猿，对于简单的使用已毫不满足，最终为了一探究竟，翻开了JDK的源码，以下观点为自己的理解及看了多篇博客的总结，欢迎各位大神指出不对的地方，当然也欢迎和我一样刚学的同学，一起加油努力吧~~

ArrayDeque是什么

ArrayDeque是什么？deque英文翻译为双向队列，ArrayDeque就是实现了Deque接口的一个双向队列的集合，ArrayDeque也是由数组实现，数组的任意位置都可以作为头或者尾，ArrayDeque不允许元素为null

ArrayDeque源码解析

在上面我们了解到了ArrayDeque是什么，大致在脑海中留下初步的印象，接下来我们来看一下源码，由于Deque继承了Queue接口，这里我们就先来看下这个接口里定义的方法

public interface Queue<E> extends Collection<E> {
    /**
     * 插入元素，成功返回true，失败抛出异常
     */
    boolean add(E e);

    /**
     * 插入元素，成功返回true，失败返回false
     */
    boolean offer(E e);

    /**
     * 获取并删除队首元素，队列为空则抛出异常
     */
    E remove();

    /**
     * 获取并删除队首元素，队列为空是返回null
     */
    E poll();

    /**
     * 获取但不删除队首元素，队列为空抛出异常
     */
    E element();

    /**
     * 获取但不删除队首元素，队列为空返回null
     */
    E peek();
}

这里的方法已经注释过，大家可以自己看下每个方法的作用，还有就是Queue是继承了Collection接口的，说明最终扔是以迭代的方式来完成的，好了，我们在大致看下Deque接口定义的方法

public interface Deque<E> extends Queue<E> {
    /**
     * 在队列最前端插入元素，无返回值
     */
    void addFirst(E e);

    /**
     * 在队列最后端插入元素，无返回值
     */
    void addLast(E e);

    /**
     * 在队列最前端插入元素，成功返回true失败返回false
     */
    boolean offerFirst(E e);

    /**
     * 在队列最后端插入元素，成功返回true失败返回false
     */
    boolean offerLast(E e);

    /**
     * 获取并删除队列最前端元素，队列为空抛出异常
     */
    E removeFirst();

    /**
     * 获取并删除队列最后端元素，队列为空抛出异常
     */
    E removeLast();

    /**
     * 获取并删除队列最前端元素，队列为空返回null
     */
    E pollFirst();

    /**
     * 获取并删除队列最后端元素，队列为空返回null
     */
    E pollLast();

    /**
     * 获取但不删除队列最前端元素，队列为空抛出异常
     */
    E getFirst();

    /**
     * 获取但不删除队列最后端元素，队列为空抛出异常
     */
    E getLast();

    /**
     * 获取但不删除队列最前端元素，队列为空返回null
     */
    E peekFirst();

    /**
     * 获取但不删除队列最后端元素，队列为空返回null
     */
    E peekLast();

    /**
     * 删除队列里第一次出现的指定元素
     */
    boolean removeFirstOccurrence(Object o);

    /**
     * 删除队列里最后一次出现的指定元素
     */
    boolean removeLastOccurrence(Object o);

    // *** Queue methods ***

    boolean add(E e);

    boolean offer(E e);

    E remove();

    E poll();

    E element();

    E peek();

    // *** Stack methods ***

    /**
     * 内存空间允许的情况下，将元素放入出现在栈中的Dqueue中
     * 成功返回true，失败抛出异常
     */
    void push(E e);

    /**
     * 删除并返回这个队列的第一个元素
     */
    E pop();


    // *** Collection methods ***

    /**
     * 删除某个元素
     */
    boolean remove(Object o);

    /**
     * 是否包含某个元素
     */
    boolean contains(Object o);

    /**
     * 元素数量
     */
    public int size();

    /**
     * 迭代
     */
    Iterator<E> iterator();

    /**
     * 返回一个顺序反转后的迭代器
     */
    Iterator<E> descendingIterator();
}

上面就是Deque接口里的方法，看起来方法很多，其实方法无非就是添加，删除，取值，只不过添加删除头部还是尾部以及返回值的不同而已，整个体系看完，接着看最主要的，ArrayDque的源码

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

上面就是ArrayDeque的继承与实现，接下来看一下定义的变量

    /**
     * 存取队列元素的数组
     */
    private transient E[] elements;

    /**
     * 队列的头
     */
    private transient int head;

    /**
     * 队列的尾
     */
    private transient int tail;

    /**
     * 创建新的队列时最小容量
     */
    private static final int MIN_INITIAL_CAPACITY = 8;

这里队列的头与尾，可以说数组中任意位置都可以为头或者尾，继续看代码

    /**
     * 无参构造，初始化大小为默认大小16
     */
    public ArrayDeque() {
        elements = (E[]) new Object[16];
    }

    /**
     * 有参构造，参数为元素数量
     */
    public ArrayDeque(int numElements) {
        allocateElements(numElements);
    }

    /**
     * 有参构造，参数为集合
     */
    public ArrayDeque(Collection<? extends E> c) {
        allocateElements(c.size());
        addAll(c);
    }

    /**
     * 初始化数组
     */
    private void allocateElements(int numElements) {
        //初始化数组的最小容量
        int initialCapacity = MIN_INITIAL_CAPACITY;
        //找到大于numElements的最小的2的幂整数
        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];
    }

上面是ArrayDeque的构造方法，感觉没什么特殊的东西，就是初始化数组，只不过一个是默认的16长度，一个是传入的参数，最后一个构造在初始化数组后，调用AbstractCollection的addAll方法将集合放入，继续看几个比较重要的方法

    /**
     * 扩容方法，当数组满了进行扩容操作，大小为原来的两倍
     */
    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);
        System.arraycopy(elements, 0, a, r, p);
        elements = (E[])a;
        head = 0;
        tail = n;
    }

    /**
     * 在队列的前端添加元素，无返回值
     */
    public void addFirst(E e) {
        if (e == null)
            throw new NullPointerException();
        elements[head = (head - 1) & (elements.length - 1)] = e;
        //判断头尾是否重合，重合即数组满了，需进行扩容
        if (head == tail)
            doubleCapacity();
    }

    /**
     * 在队列的后端添加元素，无返回值
     */
    public void addLast(E e) {
        if (e == null)
            throw new NullPointerException();
        elements[tail] = e;
        //判断头尾是否重合，重合即数组满了，需进行扩容
        if ( (tail = (tail + 1) & (elements.length - 1)) == head)
            doubleCapacity();
    }

    /**
     * 在队列的前端添加元素，调用addFirst方法，返回值true
     */
    public boolean offerFirst(E e) {
        addFirst(e);
        return true;
    }

    /**
     * 在队列的后端添加元素，调用addLast方法，返回值true
     */
    public boolean offerLast(E e) {
        addLast(e);
        return true;
    }

    /**
     * 获取并删除最前端元素
     */
    public E removeFirst() {
        E x = pollFirst();
        //为空时抛出异常
        if (x == null)
            throw new NoSuchElementException();
        return x;
    }

    /**
     * 获取并删除最后端元素
     */
    public E removeLast() {
        E x = pollLast();
        //为空时抛出异常
        if (x == null)
            throw new NoSuchElementException();
        return x;
    }

    public E pollFirst() {
        int h = head;
        //队列空为则元素为空
        E result = elements[h]; 
        if (result == null)
            return null;
        //head处置空    
        elements[h] = null; 
        //处理特殊情况，当h为elements.length-1时的情况
        head = (h + 1) & (elements.length - 1);
        return result;
    }

    public E pollLast() {
        //处理特殊情况，当tail为0时的情况
        int t = (tail - 1) & (elements.length - 1);
        E result = elements[t];
        if (result == null)
            return null;
        elements[t] = null;
        //下一个需要添加的下标
        tail = t;
        return result;
    }

    /**
     * 获取但不删除队列最前端元素
     */
    public E getFirst() {
        E x = elements[head];
        //队列为空抛出异常
        if (x == null)
            throw new NoSuchElementException();
        return x;
    }

    /**
     * 获取但不删除队列最后端元素
     */
    public E getLast() {
        E x = elements[(tail - 1) & (elements.length - 1)];
        //队列为空抛出异常
        if (x == null)
            throw new NoSuchElementException();
        return x;
    }

    /**
     * 获取但不删除队列最前端元素，队列为空返回null
     */
    public E peekFirst() {
        return elements[head]; 
    }

    /**
     * 获取但不删除队列最后端元素，队列为空返回null
     */
    public E peekLast() {
        return elements[(tail - 1) & (elements.length - 1)];
    }

好了，这里列出了ArrayDeque最主要的一些方法，其他方法大多都比较简单了，大家可以自己去翻一下源码，最后我们需要注意的是ArrayDeque存元素时，不能存入null元素，否则会报空指针异常，好了，ArrayDeque的解析到这里就结束了