Java 中查看栈顶元素的方法

简介

在 Java 编程里，栈（Stack）是一种重要的数据结构，遵循后进先出（LIFO）的原则。很多时候，我们需要查看栈顶元素但不将其从栈中移除，比如在进行一些数据验证、条件判断等操作时。本文将详细介绍在 Java 中查看栈顶元素的基础概念、使用方法、常见实践以及最佳实践，帮助读者深入理解并高效运用相关技术。

基础概念

栈（Stack）

栈是一种线性数据结构，它就像一摞盘子，最后放上去的盘子总是最先被拿走。在 Java 中，java.util.Stack 类实现了栈的功能。栈有两个主要操作：入栈（push）和出栈（pop），而查看栈顶元素（peek）是不改变栈状态的操作。

查看栈顶元素（peek）

peek 方法用于返回栈顶元素，但不会将该元素从栈中移除。这意味着栈的状态不会发生改变，栈的大小也不会减少。

使用方法

在 Java 中，java.util.Stack 类提供了 peek 方法来查看栈顶元素。以下是使用 peek 方法的基本步骤：

1. 导入 `Stack` 类

import java.util.Stack;

2. 创建 `Stack` 对象

Stack<Integer> stack = new Stack<>();

3. 向栈中添加元素

stack.push(10);
stack.push(20);
stack.push(30);

4. 查看栈顶元素

Integer topElement = stack.peek();
System.out.println("栈顶元素是: " + topElement);

完整代码示例

import java.util.Stack;

public class StackPeekExample {
    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();
        stack.push(10);
        stack.push(20);
        stack.push(30);

        Integer topElement = stack.peek();
        System.out.println("栈顶元素是: " + topElement);
    }
}

常见实践

表达式求值

在表达式求值中，我们可以使用栈来存储操作数和运算符。在计算过程中，我们需要查看栈顶元素来决定下一步的操作。

import java.util.Stack;

public class ExpressionEvaluation {
    public static int evaluate(String expression) {
        Stack<Integer> numbers = new Stack<>();
        Stack<Character> operators = new Stack<>();

        for (int i = 0; i < expression.length(); i++) {
            char ch = expression.charAt(i);

            if (Character.isDigit(ch)) {
                numbers.push(ch - '0');
            } else if (ch == '+' || ch == '-' || ch == '*' || ch == '/') {
                while (!operators.isEmpty() && precedence(operators.peek()) >= precedence(ch)) {
                    int result = applyOperation(numbers.pop(), numbers.pop(), operators.pop());
                    numbers.push(result);
                }
                operators.push(ch);
            }
        }

        while (!operators.isEmpty()) {
            int result = applyOperation(numbers.pop(), numbers.pop(), operators.pop());
            numbers.push(result);
        }

        return numbers.pop();
    }

    private static int precedence(char operator) {
        switch (operator) {
            case '+':
            case '-':
                return 1;
            case '*':
            case '/':
                return 2;
        }
        return 0;
    }

    private static int applyOperation(int a, int b, char operator) {
        switch (operator) {
            case '+':
                return a + b;
            case '-':
                return b - a;
            case '*':
                return a * b;
            case '/':
                if (a == 0) {
                    throw new UnsupportedOperationException("Cannot divide by zero");
                }
                return b / a;
        }
        return 0;
    }

    public static void main(String[] args) {
        String expression = "3+5*2";
        int result = evaluate(expression);
        System.out.println("表达式的结果是: " + result);
    }
}

括号匹配

在检查括号是否匹配时，我们可以使用栈来存储左括号，当遇到右括号时，查看栈顶元素是否是对应的左括号。

import java.util.Stack;

public class ParenthesesMatching {
    public static boolean isMatching(String expression) {
        Stack<Character> stack = new Stack<>();

        for (char ch : expression.toCharArray()) {
            if (ch == '(' || ch == '[' || ch == '{') {
                stack.push(ch);
            } else if (ch == ')' || ch == ']' || ch == '}') {
                if (stack.isEmpty()) {
                    return false;
                }
                char top = stack.peek();
                if ((ch == ')' && top == '(') || (ch == ']' && top == '[') || (ch == '}' && top == '{')) {
                    stack.pop();
                } else {
                    return false;
                }
            }
        }

        return stack.isEmpty();
    }

    public static void main(String[] args) {
        String expression = "{[()]}";
        boolean result = isMatching(expression);
        System.out.println("括号是否匹配: " + result);
    }
}

最佳实践

异常处理

在使用 peek 方法时，需要注意栈可能为空的情况。如果栈为空，调用 peek 方法会抛出 EmptyStackException 异常。因此，在调用 peek 方法之前，最好先检查栈是否为空。

import java.util.Stack;

public class StackPeekBestPractice {
    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();

        if (!stack.isEmpty()) {
            Integer topElement = stack.peek();
            System.out.println("栈顶元素是: " + topElement);
        } else {
            System.out.println("栈为空");
        }
    }
}

使用 `Deque` 代替 `Stack`

java.util.Stack 类是线程安全的，但在单线程环境下，使用 java.util.Deque 接口的实现类（如 ArrayDeque）会更高效。

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

public class DequePeekExample {
    public static void main(String[] args) {
        Deque<Integer> stack = new ArrayDeque<>();
        stack.push(10);
        stack.push(20);
        stack.push(30);

        Integer topElement = stack.peek();
        System.out.println("栈顶元素是: " + topElement);
    }
}

小结

本文详细介绍了在 Java 中查看栈顶元素的方法。我们了解了栈的基础概念，掌握了使用 peek 方法查看栈顶元素的基本步骤。通过常见实践，如表达式求值和括号匹配，我们看到了查看栈顶元素在实际应用中的重要性。同时，我们也学习了最佳实践，包括异常处理和使用 Deque 代替 Stack，以提高代码的健壮性和性能。

参考资料

《Effective Java》，作者：Joshua Bloch