`

ArrayDeque 源码分析

阅读更多
ArrayDeque不是线程安全的。
ArrayDeque不可以存取null元素,因为系统根据某个位置是否为null来判断元素的存在。
当作为栈使用时,性能比Stack好;当作为队列使用时,性能比LinkedList好。

1. 两个重要的索引:head和tail
    // 第一个元素的索引
    private transient int head;
    // 下个要添加元素的位置,为末尾元素的索引 + 1
    private transient int tail;


2. 构造方法
    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];
    }


4. 扩容
    // 扩容为原来的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)];
    }


8. 队列操作

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

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

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

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

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

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


9. 栈操作

    public void push(E e) {
        addFirst(e);
    }

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


10. 集合方法

    public int size() {
        return (tail - head) & (elements.length - 1); // 和elements.length - 1进行与操作是为了处理当tail < head时的情况。
    }

    public boolean isEmpty() {
        return head == tail; // tail位置的元素一定为空,head和tail相等,也为空。
    }

    // 向前迭代器
    public Iterator<E> iterator() {
        return new DeqIterator();
    }

    // 向后迭代器
    public Iterator<E> descendingIterator() {
        return new DescendingIterator();
    }


    private class DeqIterator implements Iterator<E> {

        private int cursor = head;

        private int fence = tail; // 迭代终止索引,同时也为了检测并发修改。

        private int lastRet = -1; // 最近的next()调用返回的索引。据此可以定位到需要删除元素的位置。

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

        public E next() {
            if (cursor == fence)
                throw new NoSuchElementException();
            E result = 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); // 游标位置加1
            return result;
        }

        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            if (delete(lastRet)) { // 如果将元素从右往左移,需要将游标减1。
                cursor = (cursor - 1) & (elements.length - 1); // 游标位置回退1。
		fence = tail; // 重置阀值。
	    }
            lastRet = -1;
        }
    }


private class DescendingIterator implements Iterator<E> {

	private int cursor = tail; // 游标开始索引为tail
	private int fence = head; // 游标的阀值为head
	private int lastRet = -1;

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

	public E next() {
		if (cursor == fence)
			throw new NoSuchElementException();
		cursor = (cursor - 1) & (elements.length - 1); // tail是下个添加元素的位置,所以要减1才是尾节点的索引。
		E result = elements[cursor];
		if (head != fence || result == null)
			throw new ConcurrentModificationException();
		lastRet = cursor;
		return result;
	}

	public void remove() {
		if (lastRet < 0)
			throw new IllegalStateException();
		if (!delete(lastRet)) { // 如果从左往右移,需要将游标加1。
			cursor = (cursor + 1) & (elements.length - 1);
			fence = head;
		}
		lastRet = -1;
	}
}


    public boolean contains(Object o) {
        if (o == null)
            return false; // ArrayDeque不可以存储null元素
        int mask = elements.length - 1;
        int i = head;
        E x;
        while ( (x = elements[i]) != null) {
            if (o.equals(x))
                return true;
            i = (i + 1) & mask; // 处理临界情况
        }
        return false;
    }

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

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

    public Object[] toArray() {
        return copyElements(new Object[size()]); // 把所有元素拷贝到新创建的Object数组上,所以对返回数组的修改不会影响该双端队列。
    }

    public <T> T[] toArray(T[] a) {
        int size = size();
        if (a.length < size) // 目标数组大小不够
            a = (T[])java.lang.reflect.Array.newInstance(
                    a.getClass().getComponentType(), size); // 利用反射创建类型为T,大小为size的数组。
	copyElements(a); // 拷贝所有元素到目标数组。
        if (a.length > size)
            a[size] = null; // 结束标识
        return a;
    }


11. Object方法

    public ArrayDeque<E> clone() {
        try {
            ArrayDeque<E> result = (ArrayDeque<E>) super.clone();
            result.elements = Arrays.copyOf(elements, elements.length); // 深度复制。
            return result;

        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
  • 大小: 10.3 KB
分享到:
评论

相关推荐

    java集合 ArrayDeque源码详细分析

    Java 集合 ArrayDeque 源码详细分析 ...ArrayDeque 的源码分析主要包括对其主要构造方法、主要属性和 Deque 接口的实现。通过对 ArrayDeque 的源码分析,我们可以更好地理解它的实现机制和使用方法。

    《求解关灯游戏》源码分析之二

    《求解关灯游戏》源码分析之二 在编程世界中,关灯游戏(Lights Out)是一款经典的逻辑游戏,它的目标是通过点击一个5x5的网格中的按钮,使得所有的灯都熄灭。每当你点击一个按钮时,它会改变自身的状态(开或关)...

    Java容器类源码详解 Deque与ArrayDeque

    ArrayDeque 的实现基于 JDK 8 中的实现,下面是对 ArrayDeque 的分析。ArrayDeque 的方法概览: public interface Queue&lt;E&gt; extends Collection&lt;E&gt; { //向队列中插入一个元素,并返回 true //如果队列已满,抛出 ...

    常见的java集合源码分析,以及面试题

    本文将深入剖析Java集合的源码,探讨其内部实现机制,并结合常见面试题,帮助你更好地理解和应用这些知识。 首先,我们从基础开始,Java集合框架主要分为两大类:List(列表)和Set(集合)。List接口包括ArrayList...

    java类源码-JavaCollection:基于JDK1.8的集合类源码分析

    在源码分析中,我们需要关注以下关键点: 1. **接口与实现类的关系**:理解`Collection`接口如何通过不同的实现类(如`ArrayList`、`LinkedList`等)来满足不同场景的需求。 2. **数据结构**:了解数组、链表、哈希...

    java各个数据结构源码

    Java的Stack类实现了栈的功能,源码分析能帮助理解push、pop等操作的实现。 4. **队列**:队列是一种先进先出(FIFO)的数据结构,适用于处理任务队列和事件驱动系统。Java的ArrayDeque类可以作为队列使用,查看其...

    java队列源码

    4. **源码分析** - 通常,实现线程安全队列的源码会包含如下关键部分: - **插入操作**:确保在队尾添加元素时不会与其他线程的读写操作冲突。 - **移除操作**:在队头移除元素时,确保元素只被一个线程处理一次...

    javabitset源码-JerrySoundCode:杰瑞声码

    bitset源码Java源码分析 基础集合列表 ArrayList (done) Vector (done) LinkedList (done) Stack (done) ReferenceQueue (done) ArrayDeque (done) Set HashSet (done) TreeSet (done) LinkedHashSet (done) BitSet ...

    Queue实现类1

    【源码分析】 对于 ArrayDeque 和 PriorityQueue,源码中包含的添加、删除和查找元素的方法都有高效的实现。ArrayDeque 的 `addFirst()` 和 `addLast()` 方法通过位运算实现元素的添加,而 `pollFirst()` 和 `...

    邓俊辉版java 数据结构源码

    在学习过程中,建议结合教材的理论部分,逐步分析和调试源码,加深对数据结构和算法的理解。同时,实践是检验理解的最佳途径,可以尝试修改和扩展源码,实现自己的数据结构,以此提升编程技能。

    java数据结构源码

    源码分析是理解这些数据结构工作原理的关键,可以帮助开发者提升程序性能和代码质量。以下是一些关于Java数据结构的核心知识点: 1. 数组:数组是最基本的数据结构,它在内存中分配连续的空间来存储相同类型的数据...

    matrix_with_given_sum-源码.rar

    由于没有具体的标签和压缩包内的文件内容,无法提供更详细的源码分析。但根据题目描述,我们可以预想源码会包含上述算法的实现,以及可能的测试用例和输出结果的验证。如果你能提供更多的上下文信息,例如源码的具体...

    Collections源码java-SE_1011_011:SE1101类的Java源文件的集合

    在源码分析中,我们还会关注到一些关键方法,如`add()`, `remove()`, `contains()`, `get()`, `size()`等,它们是集合操作的基础。同时,迭代器(Iterator)和泛型(Generics)也是集合框架的重要组成部分,它们提供...

    2017数据结构java源码.rar

    Java的ArrayDeque类可以被用作栈,源码可能包括了压入、弹出和检查栈顶元素的代码。 4. **队列**:队列是一种先进先出(FIFO)的数据结构,常用于任务调度和消息传递。Java的LinkedList类也可用于实现队列,或者...

    Java数据结构和算法源码

    源码会展示这些算法的实现过程和效率分析。 6. **图和树**:图和树是复杂数据结构,用于表示层次关系或网络结构。Java中没有内置的图或树类,但可以使用自定义类来实现,如二叉树、AVL树、红黑树等。这些数据结构...

    Java软件结构与数据结构源码

    通过分析和实践这些源码,开发者可以深入理解数据结构的工作原理,提升编程技巧,以及优化算法性能。此外,了解如何在实际软件项目中应用这些数据结构,如设计高效的数据缓存、数据库索引等,对于提升Java软件的性能...

    扫雷游戏java源码

    【扫雷游戏】是经典的一款逻辑推理类游戏,它的java源码揭示了如何用编程语言实现这个游戏的逻辑。...通过分析和理解这个源码,开发者不仅可以学习到基本的Java编程技术,还能提升解决问题和设计复杂系统的能力。

    collectionJava源码-Study_Collection:学习java集合框架

    在开源项目"Study_Collection"中,除了对这些核心接口和类的源码分析,还可能涵盖了`Map`接口及其实现,如`HashMap`、`TreeMap`和`ConcurrentHashMap`。`Map`接口用于存储键值对,它的实现方式和优化策略也值得深入...

Global site tag (gtag.js) - Google Analytics