如何用Java实现四则运算器 Java简单计算表达式功能

import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Calculator {

    // 定义操作符优先级
    private static final Map<Character, Integer> PRECEDENCE = new HashMap<>();
    static {
        PRECEDENCE.put('+', 1);
        PRECEDENCE.put('-', 1);
        PRECEDENCE.put('*', 2);
        PRECEDENCE.put('/', 2);
    }

    // 检查是否是操作符
    private static boolean isOperator(char c) {
        return PRECEDENCE.containsKey(c);
    }

    // 获取操作符优先级
    private static int getPrecedence(char op) {
        return PRECEDENCE.getOrDefault(op, 0);
    }

    // 词法分析：将表达式字符串拆分为词元列表
    public List<String> tokenize(String expression) {
        List<String> tokens = new ArrayList<>();
        Pattern pattern = Pattern.compile("(\d+\.?\d*)|([+\-*/()])"); // 匹配数字或运算符/括号
        Matcher matcher = pattern.matcher(expression.replaceAll("\s+", "")); // 移除空格

        while (matcher.find()) {
            tokens.add(matcher.group());
        }
        return tokens;
    }

    // ... 后续方法
}

// ... 接上 Calculator 类

    // 中缀表达式转后缀表达式
    public List<String> infixToPostfix(List<String> tokens) {
        List<String> postfix = new ArrayList<>();
        Stack<Character> operatorStack = new Stack<>();

        for (String token : tokens) {
            char c = token.charAt(0); // 简化处理，假设token都是单字符或完整数字

            if (Character.isDigit(c)) { // 如果是数字，直接输出
                postfix.add(token);
            } else if (c == '(') { // 左括号入栈
                operatorStack.push(c);
            } else if (c == ')') { // 右括号，弹出栈中操作符直到遇到左括号
                while (!operatorStack.isEmpty() && operatorStack.peek() != '(') {
                    postfix.add(String.valueOf(operatorStack.pop()));
                }
                if (!operatorStack.isEmpty() && operatorStack.peek() == '(') {
                    operatorStack.pop(); // 弹出左括号
                } else {
                    throw new IllegalArgumentException("Mismatched parentheses");
                }
            } else if (isOperator(c)) { // 操作符
                // 弹出栈中优先级更高或相等的运算符
                while (!operatorStack.isEmpty() && isOperator(operatorStack.peek()) &&
                       getPrecedence(c) <= getPrecedence(operatorStack.peek())) {
                    postfix.add(String.valueOf(operatorStack.pop()));
                }
                operatorStack.push(c); // 当前操作符入栈
            } else {
                throw new IllegalArgumentException("Invalid token: " + token);
            }
        }

        // 弹出栈中剩余所有操作符
        while (!operatorStack.isEmpty()) {
            if (operatorStack.peek() == '(') {
                throw new IllegalArgumentException("Mismatched parentheses");
            }
            postfix.add(String.valueOf(operatorStack.pop()));
        }
        return postfix;
    }

    // ... 后续方法

// ... 接上 Calculator 类

    // 后缀表达式求值
    public double evaluatePostfix(List<String> postfixTokens) {
        Stack<Double> operandStack = new Stack<>();

        for (String token : postfixTokens) {
            if (Character.isDigit(token.charAt(0)) || (token.length() > 1 && token.charAt(0) == '-' && Character.isDigit(token.charAt(1)))) {
                // 处理负数情况，或者更严谨地判断是否是数字
                operandStack.push(Double.parseDouble(token));
            } else if (isOperator(token.charAt(0))) {
                if (operandStack.size() < 2) {
                    throw new IllegalArgumentException("Invalid expression: not enough operands for operator " + token);
                }
                double val2 = operandStack.pop();
                double val1 = operandStack.pop();
                double result;
                switch (token.charAt(0)) {
                    case '+': result = val1 + val2; break;
                    case '-': result = val1 - val2; break;
                    case '*': result = val1 * val2; break;
                    case '/':
                        if (val2 == 0) throw new ArithmeticException("Division by zero");
                        result = val1 / val2; break;
                    default: throw new IllegalArgumentException("Unknown operator: " + token);
                }
                operandStack.push(result);
            } else {
                throw new IllegalArgumentException("Invalid token in postfix expression: " + token);
            }
        }

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

    public static void main(String[] args) {
        Calculator calculator = new Calculator();
        String expression = "3 + 4 * (2 - 1) / 2"; // 示例表达式
        // String expression = " ( 1 + 2 ) * 3 ";

        try {
            List<String> tokens = calculator.tokenize(expression);
            System.out.println("Tokens: " + tokens);

            List<String> postfix = calculator.infixToPostfix(tokens);
            System.out.println("Postfix: " + postfix);

            double result = calculator.evaluatePostfix(postfix);
            System.out.println("Result: " + result); // 期望结果：3 + 4 * 1 / 2 = 3 + 2 = 5.0
        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
        }
    }
}