文章目录

JAVA集合 Deque实现类 ArrayDeque(双端队列) 源码浅析

一、简述:
二、ArrayDeque 类结构与属性
三、ArrayDeque 构造方法
四、Queue 的方法

1. 插入元素 add(E e)
2.插入元素 offer(E e)
3.移除元素 remove()
4.移除 poll()
5.查看元素 element()
6.查看元素 peek()

五、Deque 的方法

7.添加到队列头 addFirst(E e)
8. addLast(E e)
9. getFirst()
10. getLast()
11. peekFirst()
12. peekLast()
13. pollFirst()
14.pollLast()
15.remove(Object o)
16.removeFirstOccurrence(Object o)
17.removeLastOccurrence(Object o)
18.removeFirst()
19.removeLast()
获取长度 size()
判断非空
清空 claer()

迭代器 Iterator

1.是否有下一个元素 hasNext()
2.获取下一个元素 next()
3.移除 remove()
4.迭代器剩余元素操作.forEachRemaining(Consumer<? super E> action)

JAVA集合 Deque实现类 ArrayDeque(双端队列) 源码浅析

源码来自 JDK 1.8
源码注释来自 java api 翻译

一、简述:

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

大多数 ArrayDeque 操作以摊销的固定时间运行。异常包括 remove、removeFirstOccurrence、removeLastOccurrence、contains、iterator.remove() 以及批量操作，它们均以线性时间运行。

此类的 iterator 方法返回的迭代器是快速失败的：如果在创建迭代器后的任意时间通过除迭代器本身的 remove 方法之外的任何其他方式修改了双端队列，则迭代器通常将抛出 ConcurrentModificationException。因此，面对并发修改，迭代器很快就会完全失败，而不是冒着在将来不确定的时刻任意发生不确定行为的风险。

注意，迭代器的快速失败行为不能得到保证，一般来说，存在不同步的并发修改时，不可能作出任何坚决的保证。快速失败迭代器尽最大努力抛出 ConcurrentModificationException。因此，编写依赖于此异常的程序是错误的，正确做法是：迭代器的快速失败行为应该仅用于检测 bug。

此类及其迭代器实现 Collection 和 Iterator 接口的所有可选方法。

此类是 Java Collections Framework 的成员。

二、ArrayDeque 类结构与属性

uml
在这里插入图片描述
源码的class定义：

public class ArrayDeque<E> extends AbstractCollection<E>
                           implements Deque<E>, Cloneable, Serializable
{
	transient Object[] elements; // non-private to simplify nested class access
	transient int head;	// 队列头索引
	transient int tail;	// 队列尾索引
	private static final int MIN_INITIAL_CAPACITY = 8;	// 队列初始化长度
	private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;		// 队列最大长度
}

字段	注释
elements	存储双端队列元素的数组。 deque的容量是这个数组的长度，它总是2的幂。永远不允许该数组变满，除了在addX方法中的瞬间，它在变满时立即调整大小（参见doubleCapacity），从而避免头尾缠绕到彼此相等。我们还保证所有不包含deque元素的数组单元始终为null。
head	deque头部元素的索引（即remove() 或pop() 将删除的元素）; 或者如果双端队列是空的，则任意数字等于尾部。
tail	将下一个元素添加到双端队列尾部的索引(通过addLast(E)，add(E) 或push(E))。
MIN_INITIAL_CAPACITY	将用于新创建的双端队列的最小容量。必须是2的幂。
MAX_ARRAY_SIZE	要分配的最大数组大小。一些VM在阵列中保留一些标题字。尝试分配更大的数组可能会导致OutOfMemoryError：请求的数组大小超过VM限制

三、ArrayDeque 构造方法

1、ArrayDeque()

源码注释： 构造一个初始容量能够容纳 16 个元素的空数组双端队列。

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

2、ArrayDeque(int numElements)

源码注释： 构造一个初始容量能够容纳指定数量的元素的空数组双端队列。

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

allocateElements(int numElements)

源码注释: 分配空数组,以保存给定数量的元素。

    private void allocateElements(int numElements) {
        elements = new Object[calculateSize(numElements)];
    }

calculateSize(int numElements)
源码分析： 这个方法以 2 的指数幂扩容 (8、16、32、64、128)

    private static int calculateSize(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
        }
        return initialCapacity;
    }

3、ArrayDeque(Collection<? extends E> c)

源码注释： 构造一个包含指定 collection 的元素的双端队列，这些元素按 collection 的迭代器返回的顺序排列。

源码分析: 这里的 allocateElements() 方法和 addAll() 方法下面再解析;

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

四、Queue 的方法

1. 插入元素 add(E e)

源码注释: 在此双端队列的末尾插入指定的元素。此方法等同于addLast。
如果指定的元素为null, NullPointerException

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

addLast(E e)

源码注释: 在此双端队列的末尾插入指定的元素。此方法相当于添加。

源码分析: 关键代码:如何判断队列满了, (tail = (tail + 1) & (elements.length - 1) == head, 即队列头等于队列尾
这里运用了二进制运算的技巧, 因为这个队列的长度是 2的n次方幂, 假设 16 的二进制为 10000, 16 - 1后的二进制是 1111;
所以 (tail + 1) & (elements.length - 1) 结果为 0; 10000 & 1111 = 0
在这里插入图片描述

    public void addLast(E e) {
        if (e == null)
            throw new NullPointerException();
        elements[tail] = e;
        if ( (tail = (tail + 1) & (elements.length - 1)) == head)
            doubleCapacity();
    }

doubleCapacity()
源码注释: 这个双端队列的容量增加一倍。只有在满员时才调用，即当头尾索引变得平等时。

源码分析: 扩容后是原来容量的两倍, System.arraycopy() 方法调用了两次, 这是因为为了保留原来队列元素的顺序, 先将从 head 索引开始复制数组, 再到从0 开始复制到索引tail处;

    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 = a;
        head = 0;
        tail = n;
    }

2.插入元素 offer(E e)

源码注释: 在此双端队列的末尾插入指定的元素。此方法相当于offerLast。

    public boolean offer(E e) {
        return offerLast(e);
    }

offerLast(E e)
在此双端队列的末尾插入指定的元素。

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

3.移除元素 remove()

源码注释: 检索并删除此双端队列表示的队列的头部。此方法与poll 的不同之处仅在于，如果此双端队列为空，则抛出异常。

此方法等同于removeFirst。

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

removeFirst()

源码注释: 检索并删除此双端队列的第一个元素。此方法与pollFirst的不同之处仅在于，如果此双端队列为空，则抛出异常。

    public E removeFirst() {
        E x = pollFirst();
        if (x == null)
            throw new NoSuchElementException();
        return x;
    }

pollFirst()
源码注释: 检索并删除此双端队列的第一个元素，如果此双端队列为空，则返回null。

    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;
    }

4.移除 poll()

源码注释: 检索并删除此双端队列表示的队列的头部（换句话说，此双端队列的第一个元素），如果此双端队列为空，则返回null。

此方法等同于pollFirst。

    public E poll() {
        return pollFirst();
    }

5.查看元素 element()

源码注释: 检索但不删除此双端队列表示的队列的头部。此方法与peek的不同之处仅在于，如果此双端队列为空，则会抛出异常。

此方法等同于getFirst。

    public E element() {
        return getFirst();
    }

getFirst() 查看队列第一个元素

源码注释: 检索但不删除此双端队列的第一个元素。此方法与peekFirst的不同之处仅在于，如果此双端队列为空，则抛出异常。

    public E getFirst() {
        @SuppressWarnings("unchecked")
        E result = (E) elements[head];
        if (result == null)
            throw new NoSuchElementException();
        return result;
    }

6.查看元素 peek()

源码注释: 检索但不删除此双端队列表示的队列的头部，如果此双端队列为空，则返回null。

这个方法相当于peekFirst。

    public E peek() {
        return peekFirst();
    }

peekFirst() 查看第一个元素

源码注释: 检索但不删除此双端队列的第一个元素，如果此双端队列为空，则返回null。

    public E peekFirst() {
        // elements[head] is null if deque empty
        return (E) elements[head];
    }

五、Deque 的方法

7.添加到队列头 addFirst(E e)

源码注释: 在此双端队列的前面插入指定的元素。如果指定的元素为null，则为NullPointerException

    public void addFirst(E e) {
        if (e == null)
            throw new NullPointerException();
        elements[head = (head - 1) & (elements.length - 1)] = e;
        if (head == tail)
            doubleCapacity();
    }

8. addLast(E e)

源码注释: 在此双端队列的末尾插入指定的元素。这个方法相当于 add();
NullPointerException - 如果指定的元素为null

    public void addLast(E e) {
        if (e == null)
            throw new NullPointerException();
        elements[tail] = e;
        if ( (tail = (tail + 1) & (elements.length - 1)) == head)
            doubleCapacity();
    }

9. getFirst()

源码注释: 检索但不删除此双端队列的第一个元素。此方法与peekFirst的不同之处仅在于，如果此双端队列为空，则抛出异常。
NoSuchElementException - 如果此双端队列为空

    public E getFirst() {
        @SuppressWarnings("unchecked")
        E result = (E) elements[head];
        if (result == null)
            throw new NoSuchElementException();
        return result;
    }

10. getLast()

源码注释: 检索但不删除此双端队列的最后一个元素。此方法与peekLast的不同之处仅在于，如果此双端队列为空，则抛出异常。
NoSuchElementException - 如果此双端队列为空

    public E getLast() {
        @SuppressWarnings("unchecked")
        E result = (E) elements[(tail - 1) & (elements.length - 1)];
        if (result == null)
            throw new NoSuchElementException();
        return result;
    }

11. peekFirst()

源码注释: 检索但不删除此双端队列的第一个元素，如果此双端队列为空，则返回null。
如果此双端队列为空，则返回null

    public E peekFirst() {
        // elements[head] is null if deque empty
        return (E) elements[head];
    }

12. peekLast()

源码注释: 检索但不删除此双端队列的最后一个元素，如果此双端队列为空，则返回null。
如果此双端队列为空，则返回null

    public E peekLast() {
        return (E) elements[(tail - 1) & (elements.length - 1)];
    }

13. pollFirst()

源码注释: 检索并删除此双端队列的第一个元素，如果此双端队列为空，则返回null。

    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;
    }

14.pollLast()

源码注释: 检索并删除此双端队列的最后一个元素，如果此双端队列为空，则返回null。

    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;
    }

15.remove(Object o)

源码注释: 从此双端队列中删除指定元素的单个实例。如果双端队列不包含该元素，则不会更改。更正式地，删除第一个元素e，使得o.equals（e）（如果存在这样的元素）。如果此双端队列包含指定元素，则返回true（或等效地，如果此双端队列因调用而更改）。

此方法等效于removeFirstOccurrence（Object）。

    public boolean remove(Object o) {
        return removeFirstOccurrence(o);
    }

16.removeFirstOccurrence(Object o)

源码注释: 删除此双端队列中第一次出现的指定元素（从头到尾遍历双端队列时）。如果双端队列不包含该元素，则不会更改。更正式地，删除第一个元素e，使得o.equals（e）（如果存在这样的元素）。如果此双端队列包含指定元素，则返回true（或等效地，如果此双端队列因调用而更改）。

    public boolean removeFirstOccurrence(Object o) {
        if (o == null)
            return false;
        int mask = elements.length - 1;
        int i = head;
        Object x;
        while ( (x = elements[i]) != null) {
            if (o.equals(x)) {
                delete(i);
                return true;
            }
            i = (i + 1) & mask;
        }
        return false;
    }

delete(int i)
源码注释: 删除元素数组中指定位置的元素，根据需要调整head和tail。这可能导致元件在阵列中向后或向前移动。
如果元素向后移动，则返回true

    private boolean delete(int i) {
        checkInvariants();
        final Object[] elements = this.elements;
        final int mask = elements.length - 1;
        final int h = head;
        final int t = tail;
        final int front = (i - h) & mask;
        final int back  = (t - i) & mask;

        // Invariant: head <= i < tail mod circularity
        if (front >= ((t - h) & mask))
            throw new ConcurrentModificationException();

        // Optimize for least element motion
        if (front < back) {
            if (h <= i) {
                System.arraycopy(elements, h, elements, h + 1, front);
            } else { // Wrap around
                System.arraycopy(elements, 0, elements, 1, i);
                elements[0] = elements[mask];
                System.arraycopy(elements, h, elements, h + 1, mask - h);
            }
            elements[h] = null;
            head = (h + 1) & mask;
            return false;
        } else {
            if (i < t) { // Copy the null tail as well
                System.arraycopy(elements, i + 1, elements, i, back);
                tail = t - 1;
            } else { // Wrap around
                System.arraycopy(elements, i + 1, elements, i, mask - i);
                elements[mask] = elements[0];
                System.arraycopy(elements, 1, elements, 0, t);
                tail = (t - 1) & mask;
            }
            return true;
        }
    }

17.removeLastOccurrence(Object o)

源码注释: 删除此双端队列中最后一次出现的指定元素（从头到尾遍历双端队列时）。如果双端队列不包含该元素，则不会更改。更正式地，删除最后一个元素e，使得o.equals（e）（如果存在这样的元素）。如果此双端队列包含指定元素，则返回true（或等效地，如果此双端队列因调用而更改）。

    public boolean removeLastOccurrence(Object o) {
        if (o == null)
            return false;
        int mask = elements.length - 1;
        int i = (tail - 1) & mask;
        Object x;
        while ( (x = elements[i]) != null) {
            if (o.equals(x)) {
                delete(i);
                return true;
            }
            i = (i - 1) & mask;
        }
        return false;
    }

18.removeFirst()

源码注释: 检索并删除此双端队列的第一个元素。此方法与pollFirst的不同之处仅在于，如果此双端队列为空，则抛出异常。
NoSuchElementException - 如果此双端队列为空

    public E removeFirst() {
        E x = pollFirst();
        if (x == null)
            throw new NoSuchElementException();
        return x;
    }

19.removeLast()

    public E removeLast() {
        E x = pollLast();
        if (x == null)
            throw new NoSuchElementException();
        return x;
    }

获取长度 size()

源码注释: 返回此双端队列中的元素数。

    public int size() {
        return (tail - head) & (elements.length - 1);
    }

判断非空

源码注释: 如果此双端队列不包含任何元素，则返回true。

    public boolean isEmpty() {
        return head == tail;
    }

清空 claer()

源码注释: 从此双端队列中删除所有元素。此调用返回后，双端队列将为空。

    public void clear() {
        int h = head;
        int t = tail;
        if (h != t) { // clear all cells
            head = tail = 0;
            int i = h;
            int mask = elements.length - 1;
            do {
                elements[i] = null;
                i = (i + 1) & mask;
            } while (i != t);
        }
    }

迭代器 Iterator

ArrayDeque 的迭代器实现类 DeqIterator, 只实现了 Iterator 的方法, 索引这个队列是不支持倒后迭代的.
迭代器实现类源码字段说明:

    private class DeqIterator implements Iterator<E> {
  
        private int cursor = head;

        private int fence = tail;

        private int lastRet = -1;
    }

字段	注释
cursor	后续调用next返回的元素索引。
fence	记录队列尾的索引, 如果队列被并发操作从尾部被移除元素, 则抛出异常
lastRet	最近一次调用返回的元素索引。如果通过删除调用删除元素，则重置为-1。

1.是否有下一个元素 hasNext()

        public boolean hasNext() {
            return cursor != fence;
        }

2.获取下一个元素 next()

        public E next() {
            if (cursor == fence)
                throw new NoSuchElementException();
            @SuppressWarnings("unchecked")
            E result = (E) elements[cursor];
            // This check doesn't catch all possible comodifications,
            // but does catch the ones that corrupt traversal
            if (tail != fence || result == null)
                throw new ConcurrentModificationException();
            lastRet = cursor;
            cursor = (cursor + 1) & (elements.length - 1);
            return result;
        }

3.移除 remove()

        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            if (delete(lastRet)) { // if left-shifted, undo increment in next()
                cursor = (cursor - 1) & (elements.length - 1);
                fence = tail;
            }
            lastRet = -1;
        }

4.迭代器剩余元素操作.forEachRemaining(Consumer<? super E> action)

        public void forEachRemaining(Consumer<? super E> action) {
            Objects.requireNonNull(action);
            Object[] a = elements;
            int m = a.length - 1, f = fence, i = cursor;
            cursor = f;
            while (i != f) {
                @SuppressWarnings("unchecked") E e = (E)a[i];
                i = (i + 1) & m;
                if (e == null)
                    throw new ConcurrentModificationException();
                action.accept(e);
            }
        }

持续更新:
2018-12-23

JAVA集合 Deque 与 Queue 实现类 ArrayDeque(队列、双端队列) 源码浅析