java 集合－ArrayDeque

基本概念及实例

ArrayDeque类实现Queue接口。对于数组实现的Deque来说，数据结构上比较简单，只需要一个存储数据的数组以及头尾两个索引即可。由于数组是固定长度的，所以很容易就得到数组的头和尾，那么对于数组的操作只需要移动头和尾的索引即可。

1. ArrayDeque并不是一个固定大小的队列 ， 每次队列满了以后就将队列容量扩大一倍（doubleCapacity()），因此加入一个元素总是能成功 ，而且也不会抛出一个异常。也就是说ArrayDeque是一个没有容量限制的队列;
2. 同样继续性能的考虑，使用System.arraycopy复制一个数组比循环设置要高效得多;
3. ArrayDeque不可以存取null元素，因为系统根据某个位置是否为null来判断元素的存在;
4. 当作为栈使用时，性能比Stack好；当作为队列使用时，性能比LinkedList好;
5. 它们不是线程安全的;如果没有外部同步;
6. 不支持多线程并发访问;
   结构图（来源互联网）
   
   实例1：实现栈

mport java.util.ArrayDeque;
import java.util.Deque;

public class StackbyArrayDeque <T>{
    
    private Deque<T> stack=new ArrayDeque<>();
    
    public void push(T v)
    {
        stack.addFirst(v);
    }
    
    public T pop()
    {
        return stack.removeFirst();
    }
    public T peek()
    {
        return stack.peekFirst();
    }
    
}

源码分析(原文请点击)

1. 两个重要的索引：head和tail

    // 第一个元素的索引
    private transient int head;
    // 下个要添加元素的位置，为末尾元素的索引 + 1
    private transient int tail;

1. 构造方法

    public ArrayDeque() {
        elements = (E[]) new Object[16]; // 默认的数组长度大小
    }

    public ArrayDeque(int numElements) {
        allocateElements(numElements); // 需要的数组长度大小
    }

    public ArrayDeque(Collection<? extends E> c) {
        allocateElements(c.size()); // 根据集合来分配数组大小
        addAll(c); // 把集合中元素放到数组中
    }

3.分配合适大小的数组

    private void allocateElements(int numElements) {
        int initialCapacity = MIN_INITIAL_CAPACITY;
        // 找到大于需要长度的最小的2的幂整数。
        // 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];
    }

1. 扩容

    // 扩容为原来的2倍。
    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];
        // 既然是head和tail已经重合了，说明tail是在head的左边。
        System.arraycopy(elements, p, a, 0, r); // 拷贝原数组从head位置到结束的数据
        System.arraycopy(elements, 0, a, r, p); // 拷贝原数组从开始到head的数据
        elements = (E[])a;
        head = 0; // 重置head和tail为数据的开始和结束索引
        tail = n;
    }

    // 拷贝该数组的所有元素到目标数组
    private <T> T[] copyElements(T[] a) {
        if (head < tail) { // 开始索引大于结束索引，一次拷贝
            System.arraycopy(elements, head, a, 0, size());
        } else if (head > tail) { // 开始索引在结束索引的右边，分两段拷贝
            int headPortionLen = elements.length - head;
            System.arraycopy(elements, head, a, 0, headPortionLen);
            System.arraycopy(elements, 0, a, headPortionLen, tail);
        }
        return a;
    }

5.添加元素

    public void addFirst(E e) {
        if (e == null)
            throw new NullPointerException();
        // 本来可以简单地写成head-1，但如果head为0，减1就变为-1了，和elements.length - 1进行与操作就是为了处理这种情况，这时结果为elements.length - 1。
        elements[head = (head - 1) & (elements.length - 1)] = e;
        if (head == tail) // head和tail不可以重叠
            doubleCapacity();
    }

    public void addLast(E e) {
        if (e == null)
            throw new NullPointerException();
        // tail位置是空的，把元素放到这。
        elements[tail] = e;
        // 和head的操作类似，为了处理临界情况 (tail为length - 1时)，和length - 1进行与操作，结果为0。
        if ( (tail = (tail + 1) & (elements.length - 1)) == head)
            doubleCapacity();
    }

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

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

6.删除元素

    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]; // Element is null if deque empty
        if (result == null)
            return null;
        // 表明head位置已为空
        elements[h] = null;     // Must null out slot
        head = (h + 1) & (elements.length - 1); // 处理临界情况（当h为elements.length - 1时），与后的结果为0。
        return result;
    }

    public E pollLast() {
        int t = (tail - 1) & (elements.length - 1); // 处理临界情况（当tail为0时），与后的结果为elements.length - 1。
        E result = elements[t];
        if (result == null)
            return null;
        elements[t] = null;
        tail = t; // tail指向的是下个要添加元素的索引。
        return result;
    }

删除指定元素：

    public boolean removeFirstOccurrence(Object o) {
        if (o == null)
            return false;
        int mask = elements.length - 1;
        int i = head;
        E x;
        while ( (x = elements[i]) != null) {
            if (o.equals(x)) {
                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; // 末尾元素的索引
        E x;
        while ( (x = elements[i]) != null) {
            if (o.equals(x)) {
                delete(i);
                return true;
            }
            i = (i - 1) & mask; // 从尾到头遍历
        }
        return false;
    }

    private void checkInvariants() { // 有效性检查
        assert elements[tail] == null; // tail位置没有元素
        assert head == tail ? elements[head] == null :
            (elements[head] != null &&
                elements[(tail - 1) & (elements.length - 1)] != null); // 如果head和tail重叠，队列为空；否则head位置有元素，tail-1位置有元素。
        assert elements[(head - 1) & (elements.length - 1)] == null; // head-1的位置没有元素。
    }

    private boolean delete(int i) {
        checkInvariants();
        final E[] elements = this.elements;
        final int mask = elements.length - 1;
        final int h = head;
        final int t = tail;
        final int front = (i - h) & mask; // i前面的元素个数
        final int back  = (t - i) & mask; // i后面的元素个数

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

        // Optimize for least element motion
        if (front < back) { // i的位置靠近head，移动开始的元素，返回false。
            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; // head位置后移
            return false;
        } else { // i的位置靠近tail，移动末尾的元素，返回true。
            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;
        }
    }

7:获取元素

    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)]; // 处理临界情况（当tail为0时），与后的结果为elements.length - 1。
        if (x == null)
            throw new NoSuchElementException();
        return x;
    }

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

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

转载于:https://www.cnblogs.com/csuwater/p/5400461.html