ArrayDeque作为双端队列的使用方法

ArrayDeque是Java中高效的双端队列实现，基于数组实现，支持在两端高效添加和移除元素，性能优于LinkedList，适用于栈和队列场景。它具备均摊O(1)的时间复杂度，内存连续，缓存友好，常用于BFS、LRU缓存、回文检查等场景，但不支持null元素且非线程安全，使用时应优先通过Deque接口声明，必要时选择并发替代方案。

ArrayDeque，作为Java集合框架中一个相当实用的双端队列实现，它的核心价值在于提供了一个可以在两端高效地添加和移除元素的动态数组。简单来说，它既能当栈用（后进先出），也能当队列用（先进先出），而且在大多数操作上，它的性能表现都非常出色，通常比LinkedList作为双端队列要快。

解决方案

使用ArrayDeque作为双端队列其实非常直观。你首先需要实例化一个ArrayDeque对象，然后就可以利用它提供的方法在队列的两端进行操作了。

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

public class ArrayDequeUsage {
    public static void main(String[] args) {
        // 声明时通常使用Deque接口，这是一种好的编程习惯
        Deque names = new ArrayDeque<>();

        // 在队尾添加元素 (作为队列的入队操作)
        names.addLast("Alice"); // 等同于 names.add("Alice"); 或 names.offer("Alice");
        names.offer("Bob");

        // 在队头添加元素 (作为栈的入栈操作)
        names.addFirst("Charlie");
        names.push("David"); // push方法是Deque接口特有的，语义上更明确为“入栈”

        System.out.println("当前队列内容: " + names); // 输出: [David, Charlie, Alice, Bob]

        // 从队头移除元素 (作为队列的出队操作)
        String firstElement = names.removeFirst(); // 等同于 names.remove(); 或 names.poll();
        System.out.println("移除队头元素: " + firstElement); // David
        System.out.println("移除后队列: " + names); // [Charlie, Alice, Bob]

        // 从队尾移除元素 (作为栈的出栈操作)
        String lastElement = names.removeLast(); // 等同于 names.pop();
        System.out.println("移除队尾元素: " + lastElement); // Bob
        System.out.println("移除后队列: " + names); // [Charlie, Alice]

        // 查看队头元素但不移除
        String peekFirst = names.peekFirst(); // 等同于 names.peek();
        System.out.println("查看队头元素: " + peekFirst); // Charlie

        // 查看队尾元素但不移除
        String peekLast = names.peekLast();
        System.out.println("查看队尾元素: " + peekLast); // Alice

        // 检查队列是否为空
        System.out.println("队列是否为空? " + names.isEmpty()); // false

        // 获取队列大小
        System.out.println("队列大小: " + names.size()); // 2
    }
}

这段代码展示了ArrayDeque作为双端队列的基本操作。你会发现，它提供了一系列方法，有的名称更偏向队列（如

addLast

offer

removeFirst

poll

push

pop

ArrayDeque与LinkedList作为双端队列的性能差异和选择考量

在Java里，除了ArrayDeque，LinkedList也能实现Deque接口，作为双端队列来用。那么，什么时候用哪个呢？坦白说，对于纯粹的双端队列操作，ArrayDeque几乎总是更好的选择。

ArrayDeque底层是基于数组实现的，它在内存中是连续存放的。这意味着在访问元素时，CPU缓存的命中率会很高，这对于性能来说是个巨大的优势。它的添加和移除操作（在两端）都是均摊O(1)的时间复杂度。为什么是均摊呢？因为它在内部数组满的时候需要扩容，扩容操作是O(n)的，但这种操作不常发生，所以平均下来还是非常高效的。

而LinkedList呢，它是一个双向链表。每个元素（节点）都包含数据以及指向前一个和后一个节点的引用。虽然在链表的两端添加和移除元素也是O(1)，但它的内存是非连续的。这意味着每次访问元素时，都可能需要跳到内存的不同位置，这会降低CPU缓存的效率。此外，每个节点都需要额外的内存来存储前后引用，所以LinkedList的内存开销通常会比ArrayDeque大一些。

所以，我的建议是：

• 优先选择ArrayDeque：如果你只需要一个高效的双端队列，并且不需要在队列中间频繁插入或删除元素（因为这会让LinkedList的O(1)优势发挥不出来），ArrayDeque是首选。它性能更好，内存效率也更高。
• 考虑LinkedList的情况：只有当你需要处理

  null

  元素（ArrayDeque不允许）或者确实需要在队列的任意位置进行高效的插入和删除操作时（虽然这已经超出了“双端队列”的范畴，更像是一个通用链表的使用场景），才应该考虑LinkedList。

我个人在实际项目中，只要是用到栈或队列，几乎都是无脑ArrayDeque，因为它在绝大多数场景下都能提供令人满意的性能。

ArrayDeque在实际开发中的应用场景举例

ArrayDeque的用途非常广泛，因为它兼具栈和队列的特性，使得它在处理各种数据结构和算法问题时都游刃有余。

一个非常经典的场景是广度优先搜索 (BFS)。在图或树的遍历中，BFS需要一个队列来存储待访问的节点。每访问一个节点，就将其所有未访问的邻居节点入队。ArrayDeque在这里就完美扮演了队列的角色：

addLast()

removeFirst()

深蓝企业网站管理系统1

本程序版权归作者所有不得利用本程序从事任何非法活动！本程序功能有限只能满足基础型企业网站的建站需求，无法满足更搞要求的企业站，也无法利用本程序制作门户网站，更不能建站购物站。为了克服以上技术局限，我们开发了“新坐标CMS-超级云端网站管理系统”，可以满足任何要求的企业网站，也可以制作购物网站，同时还可以制作门户型网站。其标签式调用方法让您随心所欲调用想要的结果。 使用说明：根目录包含netbox无

下载

// 伪代码示例：BFS遍历
// Deque queue = new ArrayDeque<>();
// queue.addLast(startNode);
// while (!queue.isEmpty()) {
//     Node current = queue.removeFirst();
//     // 处理current节点
//     // 将current的未访问邻居节点添加到queue.addLast()
// }

另一个非常实用的场景是实现最近最少使用 (LRU) 缓存。LRU缓存的核心思想是：当缓存空间不足时，淘汰掉最近最少使用的那个数据。这通常可以通过结合

HashMap

ArrayDeque

LinkedHashMap

// 伪代码示例：LRU缓存的访问顺序维护
// Map cacheMap = new HashMap<>();
// Deque accessOrder = new ArrayDeque<>(); // 队头是LRU，队尾是MRU

// void put(Key k, Value v) {
//     if (cacheMap.containsKey(k)) {
//         accessOrder.remove(k); // 移除旧位置
//     } else if (cacheMap.size() >= CAPACITY) {
//         Key lruKey = accessOrder.removeFirst(); // 淘汰最旧的
//         cacheMap.remove(lruKey);
//     }
//     cacheMap.put(k, v);
//     accessOrder.addLast(k); // 标记为最近使用
// }

// Value get(Key k) {
//     if (cacheMap.containsKey(k)) {
//         accessOrder.remove(k); // 移除旧位置
//         accessOrder.addLast(k); // 标记为最近使用
//         return cacheMap.get(k);
//     }
//     return null;
// }

此外，它还可以用于：

• 回文检查：将字符串字符依次入队，然后从两端同时取出字符进行比较。
• 滑动窗口最大/最小值问题：维护一个单调队列（通常用ArrayDeque实现），存储窗口内元素的索引，队头始终是当前窗口的最大/最小值。
• 表达式求值：在处理逆波兰表达式或中缀转后缀时，栈是必不可少的，ArrayDeque可以高效地扮演这个角色。

这些场景都体现了ArrayDeque在需要高效地从两端操作数据时的强大能力。

使用ArrayDeque时可能遇到的常见陷阱与最佳实践

尽管ArrayDeque非常强大，但在使用时还是有一些需要注意的地方，避免踩坑。

首先，一个非常重要的点是ArrayDeque不是线程安全的。如果你在多线程环境下使用ArrayDeque，并且有多个线程同时对其进行读写操作，那么就可能会出现数据不一致的问题。在这种情况下，你需要自己进行外部同步（例如使用

Collections.synchronizedDeque()

java.util.concurrent.ConcurrentLinkedDeque

ConcurrentLinkedDeque

其次，ArrayDeque不允许存储

null

addFirst(null)

addLast(null)

NullPointerException

再者，关于初始容量。ArrayDeque在创建时可以指定一个初始容量。虽然它会自动扩容，但如果你能预估大致的元素数量，提供一个合适的初始容量可以减少扩容的次数，从而在一定程度上提升性能。例如，

new ArrayDeque<>(100)

最后，一个最佳实践是始终使用

Deque

Deque names = new ArrayDeque<>();

总的来说，ArrayDeque是一个非常值得信赖且高效的数据结构。理解它的底层原理和特性，并注意上述的几个点，就能在实际开发中充分发挥它的优势。