集合系列 Queue(十一):ArrayDeque

从名字我们可以看出,其实一个双向队列实现,而且底层采用数组实现。

public class ArrayDeque<E> extends AbstractCollection<E>
                           implements Deque<E>, Cloneable, Serializable

从定义可以看出,其实现了 Deque 接口。

原理

为了深入理解 ArrayDeque 的原理,我们将从类成员变量、构造方法、核心方法两个方面逐一介绍。

类成员变量

// 数据数组
transient Object[] elements;
// 头结点
transient int head;
// 尾节点
transient int tail; 

从类成员变量我们就可以知道,其底层确实使用数组存储。

构造方法

ArrayDeque 一共有 3 个构造方法:

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

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

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

从第一个构造方法可以看到,其构造方法直接指定了 ArrayDeque 的初始大小为 16。

核心方法

对于双向队列来说,其关键的方法是:offer、poll、offerFirst、offerLast、pollFirst、pollLast。但其实这些方法的内容都类似,所以我们只分析 offer 和 poll 方法。

offer

public boolean offer(E e) {
    return offerLast(e);
}
    
public boolean offerLast(E e) {
    addLast(e);
    return true;
}
    
public void addLast(E e) {
    if (e == null)
        throw new NullPointerException();
    elements[tail] = e;
    // 当 tail 和 head 相遇时,表示队列已满,需要扩容
    if ( (tail = (tail + 1) & (elements.length - 1)) == head)
        doubleCapacity();
}

这里比较难懂的地方是这个判断:

if ( (tail = (tail + 1) & (elements.length - 1)) == head)
    doubleCapacity();

因为 ArrayDeque 初始容量是 16,而每次扩容都是扩为原来的两倍,所以 ArrayDeque 的容量总是 2 的幂次方。所以上面的判断其实在队列未满时,相当于将 tail 进行加一操作。

if ( (tail = (tail + 1)) == head)
    doubleCapacity();

而做这样一个与操作的目的就是在 tail 到达数组末尾时可以自动切换为 0。我们可以假设此数组大小为 16,而此时 tail 指向了 15,即末尾节点。那么此时执行 offer 操作,我们在计算 (tail + 1) & (elements.length - 1) 就会如下图所示:

10000   // tail + 1 = 15 + 1 = 16
01111   // element.length - 1 = 16 -1 =15
00000   // 结果为0

计算出的结果为 0,也就是说 tail 指针指向了 0 这个位置。

poll

public E poll() {
    return 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
    // 当处于队列末尾时,会切到队列头
    head = (h + 1) & (elements.length - 1);
    return result;
}

poll 方法也与 offer 方法类似,在最终对 head 节点加一时也用了同样的方法。

总结

看完 ArrayDeque 类的实现,我们不由得会想起 LinkedList 的实现,因为它们两个都是双向队列的实现,但是一个采用数组实现,一个采用链表实现。那么它们有什么异同呢?

通过查询一些资料发现,其实它们两个在功能和效率上并没有太大不同。如果你需要用到双向嘟列,那么 ArrayDeque 相对于 LinkedList 要更好。因为 ArrayDeque 相对于 LinkedList 直接采用数组存储,而 LinkedList 则需要采用节点存储。所以 LinkedList 相对于 ArrayDeque 需要消耗更多内存。

本身数组与链表的差异在于查询和修改的差异,但是对于队列来说,其都是在头和尾进行操作。所以数组与链表的差异在队列身上没有任何体现。而查阅 ArrayDeque 和 LinkedList 的发布时间,我们会发现 ArrayDeque 发布于 JDK 1.6,而 LinkedList 发布于 JDK 1.2。所以从这一点来看,我们有理由相信 ArrayDeque 其实是 LinkedList 的优化版本。

如果你对 LinkedList 和 ArrayDeque 的差异感兴趣,建议阅读这篇文章:Java: ArrayDeque vs. LinkedList

posted @ 2019-08-28 21:12  陈树义  阅读(...)  评论(... 编辑 收藏