鄂奎阿1. 栈的核心概念与Java实现
栈（Stack）是一种遵循后进先出（LIFO）原则的线性数据结构，就像我们日常生活中叠放的盘子——最后放上去的盘子总是最先被取用。在Java中，栈的操作主要包含以下核心方法：
- push(E item)：将元素压入栈顶
- pop()：移除并返回栈顶元素
- peek()：查看栈顶元素但不移除
- empty()：判断栈是否为空
- search(Object o)：查找元素在栈中的位置
Java提供了两种主要的栈实现方式：
java复制// 使用java.util.Stack类（继承自Vector）
Stack<Integer> stack = new Stack<>();
// 更推荐使用Deque接口的实现类
Deque<Integer> deque = new ArrayDeque<>();
注意：虽然Java保留了Stack类，但官方文档建议使用Deque接口的实现类，因为Stack作为Vector的子类存在线程安全开销，而ArrayDeque在非线程安全场景下性能更优。
1.1 栈的底层实现原理
以ArrayDeque为例，其内部通过循环数组实现栈功能：
java复制// 简化版ArrayDeque核心字段
transient Object[] elements; // 存储元素的数组
transient int head; // 头部指针
transient int tail; // 尾部指针
当执行push操作时，实际调用的是addFirst()方法：
java复制public void addFirst(E e) {
if (e == null) throw new NullPointerException();
elements[head = (head - 1) & (elements.length - 1)] = e;
if (head == tail) doubleCapacity(); // 扩容机制
}
这个位运算(head - 1) & (elements.length - 1)实现了循环数组的索引计算，当head为0时，会跳转到数组末尾。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 栈的典型应用场景
2.1 函数调用栈
Java虚拟机使用调用栈管理方法调用和返回：
java复制public class CallStackDemo {
static void method1() {
method2();
}
static void method2() {
method3();
}
static void method3() {
System.out.println("方法调用链");
}
public static void main(String[] args) {
method1();
}
}
执行时JVM会维护这样的调用栈：
code复制栈顶 -> method3()
method2()
method1()
main()
2.2 表达式求值
实现一个简单的算术表达式计算器：
java复制public static int evalExpression(String[] tokens) {
Deque<Integer> stack = new ArrayDeque<>();
for (String token : tokens) {
if (token.matches("-?\\d+")) {
stack.push(Integer.parseInt(token));
} else {
int b = stack.pop();
int a = stack.pop();
switch (token) {
case "+": stack.push(a + b); break;
case "-": stack.push(a - b); break;
case "*": stack.push(a * b); break;
case "/": stack.push(a / b); break;
}
}
}
return stack.pop();
}
2.3 括号匹配检查
java复制public static boolean isValidParentheses(String s) {
Deque<Character> stack = new ArrayDeque<>();
for (char c : s.toCharArray()) {
if (c == '(' || c == '[' || c == '{') {
stack.push(c);
} else {
if (stack.isEmpty()) return false;
char top = stack.pop();
if ((c == ')' && top != '(') ||
(c == ']' && top != '[') ||
(c == '}' && top != '{')) {
return false;
}
}
}
return stack.isEmpty();
}
3. 栈的高级应用与优化
3.1 单调栈应用
解决"下一个更大元素"问题：
java复制public static int[] nextGreaterElement(int[] nums) {
int[] res = new int[nums.length];
Arrays.fill(res, -1);
Deque<Integer> stack = new ArrayDeque<>(); // 存储索引
for (int i = 0; i < nums.length; i++) {
while (!stack.isEmpty() && nums[stack.peek()] < nums[i]) {
res[stack.pop()] = nums[i];
}
stack.push(i);
}
return res;
}
3.2 线程安全栈实现
如果需要线程安全版本，可以使用：
java复制// 使用Collections工具类
Deque<Integer> safeStack = Collections.synchronizedDeque(new ArrayDeque<>());
// 或者使用ConcurrentLinkedDeque
Deque<Integer> concurrentStack = new ConcurrentLinkedDeque<>();
3.3 栈与递归的相互转换
将递归实现的阶乘改为栈实现：
java复制// 递归版本
public static int factorialRecursive(int n) {
if (n <= 1) return 1;
return n * factorialRecursive(n - 1);
}
// 栈版本
public static int factorialStack(int n) {
Deque<Integer> stack = new ArrayDeque<>();
while (n > 1) {
stack.push(n--);
}
int result = 1;
while (!stack.isEmpty()) {
result *= stack.pop();
}
return result;
}
4. 常见问题与性能优化
4.1 栈溢出问题
递归过深导致的StackOverflowError：
java复制public class StackOverflowDemo {
static void recursiveCall() {
recursiveCall(); // 无限递归
}
public static void main(String[] args) {
recursiveCall();
}
}
解决方案：
- 增加JVM栈大小：
-Xss2m - 将递归改为迭代+显式栈
- 使用尾递归优化（Java暂不支持）
4.2 性能对比测试
不同实现的压栈操作性能对比（单位：ns/op）：
| 实现类 | 单线程 | 多线程竞争 |
|---|---|---|
| Stack | 128 | 245 |
| ArrayDeque | 56 | 不适用 |
| ConcurrentLinkedDeque | 210 | 180 |
4.3 内存占用优化
对于基本数据类型，使用特化栈减少装箱开销：
java复制// 使用Eclipse Collections的原始类型集合
IntStack stack = IntStacks.mutable.empty();
stack.push(1);
int top = stack.pop();
或者使用数组手动实现：
java复制public class IntArrayStack {
private int[] data;
private int top = -1;
public IntArrayStack(int capacity) {
data = new int[capacity];
}
public void push(int value) {
if (top == data.length - 1) {
resize();
}
data[++top] = value;
}
private void resize() {
data = Arrays.copyOf(data, data.length * 2);
}
}
5. 面试常见问题解析
5.1 经典栈问题解法
实现一个最小栈：
java复制class MinStack {
private Deque<Integer> dataStack;
private Deque<Integer> minStack;
public MinStack() {
dataStack = new ArrayDeque<>();
minStack = new ArrayDeque<>();
}
public void push(int val) {
dataStack.push(val);
if (minStack.isEmpty() || val <= minStack.peek()) {
minStack.push(val);
}
}
public void pop() {
if (dataStack.pop().equals(minStack.peek())) {
minStack.pop();
}
}
public int top() {
return dataStack.peek();
}
public int getMin() {
return minStack.peek();
}
}
5.2 栈与DFS算法
使用栈实现图的深度优先搜索：
java复制public void dfsWithStack(Node start) {
Deque<Node> stack = new ArrayDeque<>();
Set<Node> visited = new HashSet<>();
stack.push(start);
while (!stack.isEmpty()) {
Node current = stack.pop();
if (!visited.contains(current)) {
visited.add(current);
System.out.println(current.value);
// 注意压栈顺序与递归顺序相反
for (Node neighbor : current.neighbors) {
stack.push(neighbor);
}
}
}
}
5.3 系统设计中的应用
实现浏览器的前进后退功能：
java复制public class BrowserHistory {
private Deque<String> backStack;
private Deque<String> forwardStack;
private String current;
public BrowserHistory(String homepage) {
backStack = new ArrayDeque<>();
forwardStack = new ArrayDeque<>();
current = homepage;
}
public void visit(String url) {
backStack.push(current);
current = url;
forwardStack.clear(); // 清空前进栈
}
public String back(int steps) {
while (steps-- > 0 && !backStack.isEmpty()) {
forwardStack.push(current);
current = backStack.pop();
}
return current;
}
public String forward(int steps) {
while (steps-- > 0 && !forwardStack.isEmpty()) {
backStack.push(current);
current = forwardStack.pop();
}
return current;
}
}
在实际项目中，栈的应用远比这些基础示例丰富。我在处理XML解析时，就曾用栈来跟踪嵌套标签的层级关系；在开发计算器应用时，通过双栈实现了带优先级的表达式求值。理解栈的核心原理后，你会发现它就像程序世界里的"时光机"，能帮我们回溯到之前的状态，这种特性在解决许多复杂问题时非常有用。