Java Deque 方法全解析：从基础操作到方法对比

概述

本文将深入探讨 Java Deque 接口的完整方法体系，重点分析相似方法之间的行为差异和使用场景，帮助开发者全面掌握这一核心集合类型。

一、方法体系全景图

Deque 方法按照操作类型和失败行为可分为两大类别：

1.1 异常派方法（失败时抛出异常）

// 头部操作
void addFirst(E e)
E removeFirst()
E getFirst()

// 尾部操作
void addLast(E e)
E removeLast()
E getLast()

1.2 安全派方法（失败时返回特殊值）

// 头部操作
boolean offerFirst(E e)
E pollFirst()
E peekFirst()

// 尾部操作
boolean offerLast(E e)
E pollLast()
E peekLast()

二、核心方法对比矩阵

方法类别	方法签名	等效操作	空队列行为	推荐场景
插入	addFirst(e)	头部插入	抛出异常	必须成功的插入操作
	offerFirst(e)	头部插入	返回 false	容量受限的队列
	addLast(e)	尾部插入	抛出异常	传统队列的入队操作
	offerLast(e)	尾部插入	返回 false	并发队列操作
删除	removeFirst()	头部删除	抛出异常	必须成功的删除操作
	pollFirst() / poll()	头部删除	返回 null	安全删除操作
	removeLast()	尾部删除	抛出异常	栈的 pop 操作
	pollLast()	尾部删除	返回 null	双向扫描算法
检查	getFirst()	查看头部	抛出异常	必须存在的元素访问
	peekFirst() / peek()	查看头部	返回 null	安全查看操作
	getLast()	查看尾部	抛出异常	栈的 peek 操作
	peekLast()	查看尾部	返回 null	双向数据结构维护

特殊说明 ：poll() 是 pollFirst() 的别名方法，继承自 Queue 接口

三、方法行为深度解析

3.1 删除操作对比

Deque<String> deque = new ArrayDeque<>();

// 空队列时的不同表现
deque.pollFirst();    // 返回 null
deque.pollLast();     // 返回 null
deque.poll();        // 返回 null (等效 pollFirst)
deque.removeFirst();  // 抛出 NoSuchElementException
deque.removeLast();   // 抛出 NoSuchElementException
deque.pop();         // 抛出 NoSuchElementException (等效 removeFirst)

3.2 插入操作对比

// 容量受限的 Deque
Deque<Integer> fixedDeque = new ArrayDeque<>(2);

fixedDeque.offerFirst(1);  // 返回 true
fixedDeque.offerFirst(2);  // 返回 true
fixedDeque.offerFirst(3);  // 返回 false
fixedDeque.addFirst(3);    // 抛出 IllegalStateException

3.3 检查操作对比

Deque<Object> deque = new LinkedList<>();
deque.add("A");

Object val1 = deque.peek();     // 返回 "A" (不删除)
Object val2 = deque.peekLast(); // 返回 "A" 
Object val3 = deque.getFirst(); // 返回 "A"
Object val4 = deque.getLast();  // 返回 "A"

deque.clear();
Object val5 = deque.peek();     // 返回 null
Object val6 = deque.getFirst(); // 抛出异常

四、方法组合使用模式

4.1 队列模式 (FIFO)

// 入队操作
deque.offerLast("item");  // 等效 Queue.offer()
// 或
deque.addLast("item");    // 等效 Queue.add()

// 出队操作
String item = deque.pollFirst();  // 等效 Queue.poll()
// 或
String item = deque.removeFirst(); // 等效 Queue.remove()

// 查看队首
String head = deque.peekFirst();  // 等效 Queue.peek()

4.2 栈模式 (LIFO)

// 入栈
deque.push("item");       // 等效 addFirst()
// 或
deque.offerFirst("item");

// 出栈
String top = deque.pop();  // 等效 removeFirst()
// 或
String top = deque.pollFirst();

// 查看栈顶
String peek = deque.peek(); // 等效 peekFirst()

五、特殊方法解析

5.1 remove(Object o)

// 从任意位置删除元素
Deque<String> deque = new ArrayDeque<>(Arrays.asList("A", "B", "C"));
deque.remove("B");  // 返回 true
// 当前状态: [A, C]

5.2 批量操作方法

// 集合操作
deque.addAll(Arrays.asList("D", "E"));  // 等效 addLast
deque.contains("C");                   // O(n) 时间复杂度
deque.removeIf(s -> s.startsWith("A")); // 条件删除

六、实现类方法差异

方法行为	ArrayDeque	LinkedList
removeFirstOccurrence()	顺序扫描 O(n)	顺序扫描 O(n)
removeLastOccurrence()	逆序扫描 O(n)	逆序扫描 O(n)
element()	调用 getFirst()	调用 getFirst()
iterator()	快速失败	快速失败

七、最佳实践建议

1. 明确操作位置 ： • 使用 xxxFirst()/xxxLast() 显式指明操作端 • 避免混用隐式方法（如同时使用 push() 和 offerLast()）

2. 空队列处理：

   // 安全操作模板
   while (!deque.isEmpty()) {
       Object item = deque.pollLast();
       // 处理元素
   }

3. 性能敏感场景 ： • 优先使用 ArrayDeque 的批量操作方法 • 避免在 LinkedList 上进行频繁的随机访问

4. 方法选择策略：

   if (必须成功) {
       deque.addFirst(element); // 或 addLast
   } else {
       boolean success = deque.offerFirst(element);
   }
   
   try {
       Object val = deque.removeLast();
   } catch (NoSuchElementException e) {
       // 处理空队列情况
   }

八、常见误区警示

1. poll() vs pollLast()

   // ❌ 错误理解
   Deque<Integer> stack = new ArrayDeque<>();
   stack.push(1);
   stack.push(2);
   int val = stack.poll();  // 返回 2 (等效 pollFirst)
   
   // ✅ 正确用法
   int val = stack.pollLast(); // 返回 1

2. peek() 的副作用

   // 错误示范
   if (deque.peek() != null) {
       process(deque.removeFirst()); // 可能已被其他线程修改
   }
   
   // 正确做法
   Object item = deque.poll();
   if (item != null) {
       process(item);
   }

通过全面理解 Deque 的方法体系及其细微差别，开发者可以写出更健壮、高效的集合操作代码。记住：选择方法时始终考虑操作位置（头/尾）和失败处理方式（异常/返回值），这是掌握 Deque 使用的关键所在。