java实现带括号的四则运算

在Java中，实现带括号的四则运算通常需要解析和计算嵌套的数学表达式。你可以使用递归或栈来解决这个问题，最常见的是使用递归下降解析法（Recursive Descent Parsing）。以下是一个简单的例子，使用了递归方法来计算带括号的数学表达式：

import java.util.Stack;

public class InfixToPostfix {
    private static final String[] operators = {"+", "-", "*", "/", "(", ")"};

    public static double calculate(String expression) {
        Stack<Double> values = new Stack<>();
        Stack<Character> ops = new Stack<>();

        for (char c : expression.toCharArray()) {
            if (Character.isDigit(c)) {
                double num = 0;
                while (Character.isDigit(c)) {
                    num = num * 10 + (c - '0');
                    c = expression.charAt(++index);
                }
                values.push(num);
            } else if (c == '(') {
                ops.push(c);
            } else if (c == ')') {
                while (!ops.empty() && ops.peek() != '(') {
                    double right = values.pop();
                    double left = values.pop();
                    char op = ops.pop();
                    switch (op) {
                        case '+':
                            values.push(left + right);
                            break;
                        case '-':
                            values.push(left - right);
                            break;
                        case '*':
                            values.push(left * right);
                            break;
                        case '/':
                            values.push(left / right);
                            break;
                    }
                }
                ops.pop(); // pop the opening parenthesis
            } else if (operators.contains(c)) {
                while (!ops.empty() && hasPrecedence(operators.get(ops.size() - 1), c)) {
                    values.push(popAndApplyOp(ops, values));
                }
                ops.push(c);
            }
        }

        while (!ops.empty()) {
            values.push(popAndApplyOp(ops, values)); // Apply remaining operations
        }

        return values.pop();
    }

    private static boolean hasPrecedence(char op1, char op2) {
        return op1 == '(' || (op2 != '(' && (op1 == '*' || op1 == '/') && (op2 == '+' || op2 == '-')));
    }

    private static double popAndApplyOp(Stack<Character> ops, Stack<Double> values) {
        double right = values.pop();
        double left = values.pop();
        char op = ops.pop();
        switch (op) {
            case '+':
                values.push(left + right);
                break;
            case '-':
                values.push(left - right);
                break;
            case '*':
                values.push(left * right);
                break;
            case '/':
                values.push(left / right);
                break;
        }
        return left;
    }

    public static void main(String[] args) {
        System.out.println(calculate("(1 + 2) * 3 / 4")); // 输出：5.0
    }
}

在这个示例中，`calculate`方法接收一个字符串表达式，并通过递归的方式计算其值。注意这只是一个基础版本，实际应用可能还需要处理更复杂的场景，比如错误处理和空串等。