ArrayDeque源码分析

ArrayDeque双向队列,底层是数组。两个方向都可以插入和删除。作为栈时,效率超过Stack,作为队列的时候,效率超过LinkedList。

属性

    /**
     * 用来承装数据的数据
     */
    transient Object[] elements; // non-private to simplify nested class access

    /**
     * 头索引
     */
    transient int head;

    /**
     * 尾索引
     */
    transient int tail;

    /**
     * 数组的最小容量
     */
    private static final int MIN_INITIAL_CAPACITY = 8;

构造器

在这里插入图片描述

ArrayDeque()

默认构造器,默认创建容量是16的数组

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

ArrayDeque(int numElements)

用户传入容量值

    public ArrayDeque(int numElements) {
        allocateElements(numElements);
    }
    /**
     * 重新计算容量的大小,返回的是里numElements最小的2的幂次
     */
    private void allocateElements(int numElements) {
        elements = new Object[calculateSize(numElements)];
    }

    private static int calculateSize(int numElements) {
        int initialCapacity = MIN_INITIAL_CAPACITY;
        // 通过位运算得到最近的2的幂次,如果是6,得到是8,如果是16,得到的是32,如果是7得到的是8.
        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;
    }

ArrayDeque(Collection<? extends E> c)

传入的是一个列表

    public ArrayDeque(Collection<? extends E> c) {
    	// 重新计算容量,创建数组
        allocateElements(c.size());
        // 调用AbstracCollection类的addALL,自身没有重写该方法
        addAll(c);
    }
    public boolean addAll(Collection<? extends E> c) {
        boolean modified = false;
        for (E e : c)
            if (add(e))
                modified = true;
        return modified;
    }
    
    public boolean add(E e) {
    	//默认是添加在最后的
        addLast(e);
        return true;
    }
    // 一开始head和tail都是0,
    // 需要注意的是如果数组的长度是8,head添加是添加的索引是7,tail添加的索引是0
    public void addLast(E e) {
        if (e == null)
            throw new NullPointerException();
        // 设置数据
        elements[tail] = e;
        // 重新计算tail的值
        if ( (tail = (tail + 1) & (elements.length - 1)) == head)
            doubleCapacity();
    }


添加操作

在这里插入图片描述
add()和addLast()已经介绍过了

addFirst(E e)

    public void addFirst(E e) {
        if (e == null)
            throw new NullPointerException();
        // 先计算head的值,由于head指向的是数据所以最大的位置,下次添加的时候要向前移动
        // 之后再添加数据
        elements[head = (head - 1) & (elements.length - 1)] = e;
        if (head == tail)
            doubleCapacity();
    }

注意,头索引是先计算后添加,而尾索引是先添加后计算;也就是说头索引指向的最近添加的数据,而尾索引指向的是添加位置的索引。头结点指向的是索引最大的位置,下次添加的时候向前移动,而尾索引指向的是索引最小的位置,下次添加的时候直接向后移动

队列的添加方法

在这里插入图片描述
在这里插入图片描述

栈的添加方法

默认是添加在头。
在这里插入图片描述

删除,这里是出栈或者出队列的操作

pollFirst()

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

pollLast()

    public E pollLast() {
        // 先计算tail的值
        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;
    }

其他方法

在这里插入图片描述

出栈方法

在这里插入图片描述

查询方法

这里需要住一个是getLast()方法,由于尾指针指向的是要添加的位置,索引要退回一个索引,查询是的时候先计算tail的位置。
在这里插入图片描述

队列的方法

在这里插入图片描述

扩容

注意到在添加的时候head==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;
    }

head指向的是最近添加的数据,所以5是head指针添加的
在这里插入图片描述

已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 数字20 设计师:CSDN官方博客 返回首页