菜鸟看源码之ArrayDeque

//储存元素的数组，长度总是2的次幂，数组不允许饱和，在使用addX方法添加元素以后，如果数组饱和了，那么就会立即扩容到原来长度的两倍
transient Object[] elements;
//双端队列的头部元素的下标
transient int head;
//标志：如果一个新元素要被添加到双端队列尾部(通过 addLast(E), add(E), or push(E))，那么这个新元素在双端队列的下标就是tail
transient int tail;
//elements最小初始容量，如果构造函数指定初始容量下限小于8，那么就选择8作为初始容量
private static final int MIN_INITIAL_CAPACITY = 8;

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

//指定初始容量下限，最终初始容量是大于等于numElements并且是2的次幂的一个数，比如指定numElements=9，那么初始容量最终会是16
public ArrayDeque(int numElements) {
        allocateElements(numElements);
    }

//使用一个集合初始化队列
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;
        if (head == tail)
            doubleCapacity();
    }

ArrayDeque<Integer> deque = new ArrayDeque<>(7);
for (int i = 0; i < 8; i++) {
            deque.addFirst(i);
        }

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

ArrayDeque<Integer> deque = new ArrayDeque<>(7);
for (int i = 0; i < 8; i++) {
            deque.addLast(i);
        }

public boolean offerFirst(E e) {
        addFirst(e);
        return true;
    }

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

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

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

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

//返回队列第一个元素，但是不删除，如果为null，怎抛出异常
public E getFirst() {
        @SuppressWarnings("unchecked")
        E result = (E) elements[head];
        if (result == null)
            throw new NoSuchElementException();
        return result;
    }

//返回队列最后一个元素，但是不删除，如果为null，怎抛出异常
    public E getLast() {
        @SuppressWarnings("unchecked")
        E result = (E) elements[(tail - 1) & (elements.length - 1)];
        if (result == null)
            throw new NoSuchElementException();
        return result;
    }
//返回队列第一个元素，但是不删除，返回值可以为null
    @SuppressWarnings("unchecked")
    public E peekFirst() {
        // elements[head] is null if deque empty
        return (E) elements[head];
    }
//返回队列最后一个元素，但是不删除，返回值可以为null
    @SuppressWarnings("unchecked")
    public E peekLast() {
        return (E) elements[(tail - 1) & (elements.length - 1)];
    }

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删除,delete方法通过移动elelemts中的元素，来覆盖要删除位置上的元素，并对移动元素做了相关优化，并相应的改变head和tail
                delete(i);
                return true;
            }
            i = (i + 1) & mask;
        }
        return false;
    }

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

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