java代码怎样实现栈的括号匹配功能 java代码栈应用场景的实现方法​

java.util.Deque

Stack

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.HashMap;
import java.util.Map;

public class ParenthesisMatcher {

    public boolean isValid(String s) {
        // 使用ArrayDeque作为栈，比java.util.Stack更推荐
        Deque<Character> stack = new ArrayDeque<>();
        // 预设匹配规则，方便查找
        Map<Character, Character> mappings = new HashMap<>();
        mappings.put(')', '(');
        mappings.put('}', '{');
        mappings.put(']', '[');

        for (char c : s.toCharArray()) {
            if (mappings.containsKey(c)) { // 如果是右括号
                // 栈为空或栈顶元素不匹配，则无效
                if (stack.isEmpty() || stack.pop() != mappings.get(c)) {
                    return false;
                }
            } else { // 如果是左括号，压入栈中
                stack.push(c);
            }
        }

        // 遍历完所有字符后，如果栈为空，则所有括号都已匹配
        return stack.isEmpty();
    }

    // 可以在这里添加一个main方法测试
    public static void main(String[] args) {
        ParenthesisMatcher matcher = new ParenthesisMatcher();
        System.out.println("()[]{} is valid: " + matcher.isValid("()[]{}")); // true
        System.out.println("([{}]) is valid: " + matcher.isValid("([{}])")); // true
        System.out.println("(] is valid: " + matcher.isValid("(]"));         // false
        System.out.println("({[ is valid: " + matcher.isValid("({["));       // false
        System.out.println("}} is valid: " + matcher.isValid("}}"));         // false
        System.out.println(" is valid: " + matcher.isValid(""));             // true
    }
}

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

public class PostfixEvaluator {

    public int evaluate(String expression) {
        Deque<Integer> stack = new ArrayDeque<>();
        String[] tokens = expression.split(" "); // 假设数字和运算符用空格分隔

        for (String token : tokens) {
            if (token.matches("-?\d+")) { // 如果是数字（包括负数）
                stack.push(Integer.parseInt(token));
            } else { // 如果是运算符
                if (stack.size() < 2) {
                    throw new IllegalArgumentException("Invalid postfix expression: not enough operands for operator " + token);
                }
                int operand2 = stack.pop(); // 先弹出的作为第二个操作数
                int operand1 = stack.pop(); // 后弹出的作为第一个操作数
                int result;
                switch (token) {
                    case "+":
                        result = operand1 + operand2;
                        break;
                    case "-":
                        result = operand1 - operand2;
                        break;
                    case "*":
                        result = operand1 * operand2;
                        break;
                    case "/":
                        if (operand2 == 0) {
                            throw new ArithmeticException("Division by zero");
                        }
                        result = operand1 / operand2;
                        break;
                    default:
                        throw new IllegalArgumentException("Unknown operator: " + token);
                }
                stack.push(result);
            }
        }

        if (stack.size() != 1) {
            throw new IllegalArgumentException("Invalid postfix expression: too many operands or malformed");
        }
        return stack.pop();
    }

    public static void main(String[] args) {
        PostfixEvaluator evaluator = new PostfixEvaluator();
        System.out.println("3 4 + 5 * = " + evaluator.evaluate("3 4 + 5 *")); // (3+4)*5 = 35
        System.out.println("10 2 / = " + evaluator.evaluate("10 2 /"));     // 10/2 = 5
        System.out.println("5 1 2 + 4 * + 3 - = " + evaluator.evaluate("5 1 2 + 4 * + 3 -")); // 5 + ((1+2)*4) - 3 = 5 + 12 - 3 = 14
    }
}

java.util.Deque

ArrayDeque

LinkedList

java.util.Stack

Stack

Vector

Deque

push()

pop()

peek()

Stack

Collections.synchronizedList(new LinkedList<>())

ConcurrentLinkedDeque

ArrayDeque

pop()

peek()

EmptyStackException