详解 Java 中的双端队列（ArrayDeque附源码分析）

沉默王二约 4061 字大约 14 分钟

6.8 双端队列ArrayDeque详解

好，我们这节继续有请王老师上台来给大家讲 ArrayDeque，鼓掌欢迎了👏🏻。

Java 里有一个叫做 Stack 的类，却没有叫做 Queue 的类（它只是个接口名字，和类还不一样）。

public interface Queue<E> extends Collection<E> {}

当需要使用栈时，Java 已不推荐使用 Stack ，而是推荐使用更高效的 ArrayDeque （双端队列），原因我们第一次讲集合框架 open in new window 的时候，其实已经聊过了，Stack 是一个“原始”类，它的核心方法上都加了 synchronized 关键字以确保线程安全，当我们不需要线程安全（比如说单线程环境下）性能就会比较差。

也就是说，当需要使用栈时候，请首选 ArrayDeque 。

// 声明一个双端队列
ArrayDeque<String> stack = new ArrayDeque<>();
// 增加元素
stack.push("沉默");
stack.push("王二");
stack.push("陈清扬");
// 获取栈顶元素
String top = stack.peek();
System.out.println("栈顶元素为：" + top); // 陈清扬
// 弹出栈顶元素
String pop = stack.pop();
System.out.println("弹出的元素为：" + pop); // 陈清扬
// 修改栈顶元素
stack.pop();
stack.push("小明");
System.out.println("修改后的栈为：" + stack); // [小明, 沉默]
// 遍历队列查找元素
Iterator<String> iterator = stack.iterator();
int index = -1;
String target = "王二";
while (iterator.hasNext()) {
    String element = iterator.next();
    index++;
    if (element.equals(target)) {
        break;
if (index == -1) {
    System.out.println("元素 " + target + " 不存在于队列中");
} else {
    System.out.println("元素 " + target + " 在队列中的位置为：" + index);

在上面的示例中，我们先创建了一个 ArrayDeque 对象，然后使用 push 方法向栈中添加了三个元素。接着使用 peek 方法获取栈顶元素，使用 pop 方法弹出栈顶元素，使用 pop 和 push 方法修改栈顶元素，使用迭代器查找元素在栈中的位置。

ArrayDeque 又实现了 Deque 接口（Deque 又实现了 Queue 接口）：

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

因此，当我们需要使用队列的时候，也可以选择 ArrayDeque。

ArrayDeque<String> queue = new ArrayDeque<>();
// 增加元素
queue.offer("沉默");
queue.offer("王二");
queue.offer("陈清扬");
// 获取队首元素
String front = queue.peek();
System.out.println("队首元素为：" + front); // 沉默
// 弹出队首元素
String poll = queue.poll();
System.out.println("弹出的元素为：" + poll); // 沉默
// 修改队列中的元素
queue.poll();
queue.offer("小明");
System.out.println("修改后的队列为：" + queue); // [陈清扬, 小明]
// 查找元素
Iterator<String> iterator = queue.iterator();
int index = 0;
while (iterator.hasNext()) {
    String element = iterator.next();
    if (element.equals("王二")) {
        System.out.println("元素在队列中的位置为：" + index); // 0
        break;
    index++;

在上面的示例中，我们先创建了一个 ArrayDeque 对象，然后使用 offer 方法向队列中添加了三个元素。接着使用 peek 方法获取队首元素，使用 poll 方法弹出队首元素，使用 poll 和 offer 方法修改队列中的元素，使用迭代器查找元素在队列中的位置。

我们前面讲了 open in new window ，LinkedList不只是个 List，还是一个 Queue，它也实现了 Deque 接口。

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable

所以，当我们需要使用队列时，还可以选择 LinkedList open in new window 。

// 创建一个 LinkedList 对象
LinkedList<String> queue = new LinkedList<>();
// 添加元素
queue.offer("沉默");
queue.offer("王二");
queue.offer("陈清扬");
System.out.println(queue); // 输出 [沉默, 王二, 陈清扬]
// 删除元素
queue.poll();
System.out.println(queue); // 输出 [王二, 陈清扬]
// 修改元素：LinkedList 中的元素不支持直接修改，需要先删除再添加
String first = queue.poll();
queue.offer("王大二");
System.out.println(queue); // 输出 [陈清扬, 王大二]
// 查找元素：LinkedList 中的元素可以使用 get() 方法进行查找
System.out.println(queue.get(0)); // 输出 陈清扬
System.out.println(queue.contains("沉默")); // 输出 false
// 查找元素：使用迭代器的方式查找陈清扬
// 使用迭代器依次遍历元素并查找
Iterator<String> iterator = queue.iterator();
while (iterator.hasNext()) {
    String element = iterator.next();
    if (element.equals("陈清扬")) {
        System.out.println("找到了：" + element);
        break;

在使用 LinkedList 作为队列时，可以使用 offer() 方法将元素添加到队列的末尾，使用 poll() 方法从队列的头部删除元素，使用迭代器或者 poll() 方法依次遍历元素。

栈和队列

要讲栈和队列，首先要讲 Deque 接口。 Deque 的含义是“double ended queue”，即双端队列，它既可以当作栈使用，也可以当作队列使用。下表列出了 Deque 与 Queue 相对应的接口：

Queue Method	Equivalent Deque Method	说明
add(e)	addLast(e)	向队尾插入元素，失败则抛出异常
offer(e)	offerLast(e)	向队尾插入元素，失败则返回 `false`
remove()	removeFirst()	获取并删除队首元素，失败则抛出异常
poll()	pollFirst()	获取并删除队首元素，失败则返回 `null`
element()	getFirst()	获取但不删除队首元素，失败则抛出异常
peek()	peekFirst()	获取但不删除队首元素，失败则返回 `null`

下表列出了 Deque 与 Stack 对应的接口：

Stack Method	Equivalent Deque Method	说明
push(e)	addFirst(e)	向栈顶插入元素，失败则抛出异常
无	offerFirst(e)	向栈顶插入元素，失败则返回 `false`
pop()	removeFirst()	获取并删除栈顶元素，失败则抛出异常
无	pollFirst()	获取并删除栈顶元素，失败则返回 `null`
peek()	getFirst()	获取但不删除栈顶元素，失败则抛出异常
无	peekFirst()	获取但不删除栈顶元素，失败则返回 `null`

上面两个表共定义了 Deque 的 12 个接口。

添加，删除，取值都有两套接口，它们功能相同，区别是对失败情况的处理不同。

一套接口遇到失败就会抛出异常，另一套遇到失败会返回特殊值（ false 或 null ）。除非某种实现对容量有限制，大多数情况下，添加操作是不会失败的。

虽然 Deque 的接口有 12 个之多，但无非就是对容器的两端进行操作，或添加，或删除，或查看。明白了这一点讲解起来就会非常简单。

ArrayDeque 和 LinkedList 是 Deque 的两个通用实现，由于官方更推荐使用 ArrayDeque 用作栈和队列，加之上一篇已经讲解过 LinkedList open in new window ，本文将着重讲解 ArrayDeque 的具体实现。

从名字可以看出 ArrayDeque 底层通过数组实现，为了满足可以同时在数组两端插入或删除元素的需求，该数组还必须是循环的，即 循环数组（circular array） ，也就是说数组的任何一点都可能被看作起点或者终点。

ArrayDeque 是非线程安全的（not thread-safe），当多个线程同时使用的时候，需要手动同步；另外，该容器不允许放入 null 元素。

上图中我们看到， head 指向首端第一个有效元素， tail 指向尾端第一个可以插入元素的空位。因为是循环数组，所以 head 不一定总等于 0， tail 也不一定总是比 head 大。

方法剖析

addFirst()

addFirst(E e) 的作用是在 Deque 的首端插入元素，也就是在 head 的前面插入元素，在空间足够且下标没有越界的情况下，只需要将 elements[--head] = e 即可。

实际需要考虑：

空间是否够用，以及
下标是否越界的问题。

上图中，如果 head 为 0 之后接着调用 addFirst() ，虽然空余空间还够用，但 head 为 -1 ，下标越界了。下列代码很好的解决了这两个问题。

//addFirst(E e)
public void addFirst(E e) {
    if (e == null)//不允许放入null
        throw new NullPointerException();
    elements[head = (head - 1) & (elements.length - 1)] = e;//2.下标是否越界
    if (head == tail)//1.空间是否够用
        doubleCapacity();//扩容

上述代码我们看到， 空间问题是在插入之后解决的 ，因为 tail 总是指向下一个可插入的空位，也就意味着 elements 数组至少有一个空位，所以插入元素的时候不用考虑空间问题。

下标越界的处理解决起来非常简单， head = (head - 1) & (elements.length - 1) 就可以了，这段代码相当于取余，同时解决了 head 为负值的情况。因为 elements.length 必需是 2 的指数倍， elements - 1 就是二进制低位全 1 ，跟 head - 1 相与之后就起到了取模的作用，如果 head - 1 为负数（其实只可能是-1），则相当于对其取相对于 elements.length 的补码。

下面再说说扩容函数 doubleCapacity() ，其逻辑是申请一个更大的数组（原数组的两倍），然后将原数组复制过去。过程如下图所示：

图中我们看到，复制分两次进行，第一次复制 head 右边的元素，第二次复制 head 左边的元素。

//doubleCapacity()
private void doubleCapacity() {
    assert head == tail;
    int p = head;
    int n = elements.length;
    int r = n - p; // head右边元素的个数
    int newCapacity = n << 1;//原空间的2倍
    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 = (E[])a;
    head = 0;
    tail = n;

该方法的实现中，首先检查 head 和 tail 是否相等，如果不相等则抛出异常。然后计算出 head 右边的元素个数 r，以及新的容量 newCapacity，如果 newCapacity 太大则抛出异常。

接下来创建一个新的 Object 数组 a，将原有 ArrayDeque 中 head 右边的元素复制到 a 的前面（即图中绿色部分），将 head 左边的元素复制到 a 的后面（即图中灰色部分）。最后将 elements 数组替换为 a，head 设置为 0，tail 设置为 n（即新容量的长度）。

需要注意的是，由于 elements 数组被替换为 a 数组，因此在方法调用结束后，原有的 elements 数组将不再被引用，会被垃圾回收器回收。

addLast()

addLast(E e) 的作用是在 Deque 的尾端插入元素，也就是在 tail 的位置插入元素，由于 tail 总是指向下一个可以插入的空位，因此只需要 elements[tail] = e; 即可。插入完成后再检查空间，如果空间已经用光，则调用 doubleCapacity() 进行扩容。

public void addLast(E e) {
    if (e == null)//不允许放入null
        throw new NullPointerException();
    elements[tail] = e;//赋值
    if ( (tail = (tail + 1) & (elements.length - 1)) == head)//下标越界处理
        doubleCapacity();//扩容

下标越界处理方式 addFirt() 中已经讲过，不再赘述。

pollFirst()

pollFirst() 的作用是删除并返回 Deque 首端元素，也即是 head 位置处的元素。如果容器不空，只需要直接返回 elements[head] 即可，当然还需要处理下标的问题。由于 ArrayDeque 中不允许放入 null ，当 elements[head] == null 时，意味着容器为空。

public E pollFirst() {
    E result = elements[head];
    if (result == null)//null值意味着deque为空
        return null;
    elements[h] = null;//let GC work
    head = (head + 1) & (elements.length - 1);//下标越界处理
    return result;

pollLast()

pollLast() 的作用是删除并返回 Deque 尾端元素，也即是 tail 位置前面的那个元素。

public E pollLast() {
    int t = (tail - 1) & (elements.length - 1);//tail的上一个位置是最后一个元素
    E result = elements[t];
    if (result == null)//null值意味着deque为空
        return null;
    elements[t] = null;//let GC work
    tail = t;
    return result;

peekFirst()

peekFirst() 的作用是返回但不删除 Deque 首端元素，也即是 head 位置处的元素，直接返回 elements[head] 即可。

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

peekLast()

peekLast() 的作用是返回但不删除 Deque 尾端元素，也即是 tail 位置前面的那个元素。

public E peekLast() {

# 栈和队列

# 方法剖析

# addFirst()

# addLast()

栈和队列

方法剖析

addFirst()

addLast()