怎么让java计算字符串 “string a =(2+3)*5 “？

在 Java 编程的奇妙世界中，我们常常会遇到各种有趣的挑战。其中一个引人入胜的问题是：当给定一个字符串，例如 string a = "(2+3)*5";，我们如何让 Java 程序准确地计算出这个字符串表达式的值呢？这不仅是对 Java 语言掌握程度的考验，更是深入理解编程逻辑和算法的绝佳机会。在本文中，我们将深入探讨这个问题，逐步揭开 Java 计算字符串表达式的神秘面纱。

一、问题的引入

想象一下，你正在开发一个复杂的应用程序，其中需要动态地计算一些数学表达式，而这些表达式是以字符串的形式提供的。比如在财务软件中，用户输入的计算公式；在科学计算应用中，从外部文件读取的表达式等。这时候，我们就需要一种可靠的方法来解析和计算这些字符串表达式。

以我们的示例字符串 string a = "(2+3)*5"; 来说，直观上我们可以看出这个表达式的结果应该是 25。但是，如何让 Java 程序自动地进行这样的计算呢？这可不是一个简单的任务，它涉及到字符串处理、数学运算、算法设计等多个方面的知识。

二、字符串表达式计算的挑战

（一）语法复杂性

字符串表达式可以包含各种数学运算符，如加（+）、减（-）、乘（*）、除（/），还可能包含括号来改变运算的优先级。例如，表达式 (2+3)*5 中，括号的存在使得先计算 2+3，然后再乘以 5。如果没有正确处理括号，计算结果可能会错误。

（二）数字的提取

在字符串中，数字可能是一位数、两位数甚至多位数。我们需要一种有效的方法来识别和提取这些数字。例如，在字符串 "123 + 456" 中，我们需要准确地提取出 123 和 456 这两个数字。

（三）运算符的处理

不同的运算符有不同的优先级。乘法和除法通常比加法和减法优先级高。在计算过程中，我们需要根据运算符的优先级来确定计算的顺序。例如，在表达式 2 + 3 * 4 中，应该先计算 3 * 4，然后再加上 2。

（四）错误处理

如果输入的字符串表达式格式不正确，或者包含无法识别的字符，我们需要能够检测到这些错误并给出适当的错误提示。例如，字符串 "2 + a * 3" 中，如果 a 不是一个有效的数字，程序应该能够识别并报告错误。

三、解决方案的思路

为了解决字符串表达式计算的问题，我们可以采用以下思路：

（一）栈的数据结构

栈是一种非常有用的数据结构，它遵循 “后进先出”（Last In First Out，LIFO）的原则。在计算字符串表达式时，我们可以使用两个栈，一个用于存储数字，另一个用于存储运算符。

当遇到数字时，我们将其压入数字栈；当遇到运算符时，我们根据运算符的优先级来决定是否将当前运算符压入运算符栈，或者从数字栈中弹出两个数字，结合当前运算符进行计算，然后将结果压回数字栈。

（二）括号的处理

对于括号，我们可以使用递归的方法来处理。当遇到左括号时，我们开始一个新的计算过程，直到遇到右括号为止。在这个过程中，我们将计算结果作为一个数字处理，继续参与外部的计算。

（三）运算符优先级的确定

为了正确处理运算符的优先级，我们可以为每个运算符分配一个优先级值。在计算过程中，当遇到一个新的运算符时，我们将其优先级与运算符栈顶的运算符优先级进行比较。如果新运算符的优先级高于栈顶运算符的优先级，我们将其压入运算符栈；否则，我们从数字栈中弹出两个数字，结合栈顶运算符进行计算，然后将结果压回数字栈，再继续比较新运算符与新的栈顶运算符的优先级。

四、代码实现

以下是用 Java 实现计算字符串表达式的代码：

import java.util.Stack;

public class ExpressionCalculator {
    public static int calculate(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)) {
                int num = 0;
                while (i < expression.length() && Character.isDigit(expression.charAt(i))) {
                    num = num * 10 + (expression.charAt(i) - '0');
                    i++;
                }
                i--;
                numbers.push(num);
            } else if (ch == '(') {
                operators.push(ch);
            } else if (ch == ')') {
                while (!operators.isEmpty() && operators.peek()!= '(') {
                    int result = performOperation(numbers, operators);
                    numbers.push(result);
                }
                operators.pop();
            } else if (ch == '+' || ch == '-' || ch == '*' || ch == '/') {
                while (!operators.isEmpty() && precedence(ch) <= precedence(operators.peek())) {
                    int result = performOperation(numbers, operators);
                    numbers.push(result);
                }
                operators.push(ch);
            }
        }

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

        return numbers.pop();
    }

    private static int performOperation(Stack<Integer> numbers, Stack<Character> operators) {
        int num2 = numbers.pop();
        int num1 = numbers.pop();
        char operator = operators.pop();

        switch (operator) {
            case '+':
                return num1 + num2;
            case '-':
                return num1 - num2;
            case '*':
                return num1 * num2;
            case '/':
                return num1 / num2;
            default:
                return 0;
        }
    }

    private static int precedence(char operator) {
        if (operator == '+' || operator == '-') {
            return 1;
        } else if (operator == '*' || operator == '/') {
            return 2;
        } else {
            return 0;
        }
    }

    public static void main(String[] args) {
        String expression = "(2+3)*5";
        int result = calculate(expression);
        System.out.println("The result of expression '" + expression + "' is: " + result);
    }
}

让我们逐步分析这段代码：

（一）主要方法 `calculate`

这个方法接受一个字符串表达式作为参数，并返回计算结果。它使用两个栈，numbers 用于存储数字，operators 用于存储运算符。

在循环中，遍历表达式的每个字符。如果字符是数字，就提取出完整的数字并压入数字栈。如果字符是左括号，将其压入运算符栈。如果字符是右括号，就从数字栈中弹出两个数字，结合运算符栈中的运算符进行计算，直到遇到左括号为止，然后将左括号从运算符栈中弹出。如果字符是运算符，就根据运算符的优先级进行处理。

最后，当遍历完整个表达式后，从数字栈和运算符栈中依次取出元素进行计算，直到运算符栈为空，此时数字栈中的唯一元素就是表达式的结果。

（二）辅助方法 `performOperation`

这个方法用于执行具体的数学运算。它接受数字栈和运算符栈作为参数，从数字栈中弹出两个数字，结合运算符栈中的运算符进行计算，并返回结果。

（三）辅助方法 `precedence`

这个方法用于确定运算符的优先级。它接受一个运算符作为参数，并返回一个整数表示优先级。乘法和除法的优先级高于加法和减法。

五、代码测试与验证

为了确保我们的代码能够正确计算各种字符串表达式，我们可以进行一些测试。以下是一些测试用例：

public class ExpressionCalculatorTest {
    public static void main(String[] args) {
        // 简单的加法表达式
        String expression1 = "2+3";
        int result1 = ExpressionCalculator.calculate(expression1);
        System.out.println("The result of expression '" + expression1 + "' is: " + result1);

        // 包含括号的表达式
        String expression2 = "(2+3)*5";
        int result2 = ExpressionCalculator.calculate(expression2);
        System.out.println("The result of expression '" + expression2 + "' is: " + result2);

        // 复杂的表达式
        String expression3 = "2*(3+4)-5/2";
        int result3 = ExpressionCalculator.calculate(expression3);
        System.out.println("The result of expression '" + expression3 + "' is: " + result3);

        // 带有错误表达式的测试
        String expression4 = "2+a*3";
        try {
            int result4 = ExpressionCalculator.calculate(expression4);
            System.out.println("The result of expression '" + expression4 + "' is: " + result4);
        } catch (NumberFormatException e) {
            System.out.println("Error: Invalid expression '" + expression4 + "'.");
        }
    }
}

在上述测试用例中，我们测试了简单的加法表达式、包含括号的表达式、复杂的表达式以及带有错误的表达式。对于错误的表达式，程序应该能够捕获异常并给出适当的错误提示。