java实现输入一串含有四则运算的算式返回计算结果

可以使用逆波兰表达式求解算式的值。具体步骤如下：

1. 将中缀表达式转换为后缀表达式（即逆波兰表达式）。

2. 从左到右扫描后缀表达式，遇到数字则入栈，遇到运算符则弹出栈顶的两个数字进行计算，并将计算结果入栈。

3. 最后栈中剩下的数字即为计算结果。

其中，中缀表达式转换为后缀表达式可以使用栈来实现，具体步骤如下：

1. 初始化一个空栈和一个空的后缀表达式。

2. 从左到右扫描中缀表达式，遇到数字则直接添加到后缀表达式中，遇到运算符则与栈顶的运算符进行比较：

- 如果栈为空或栈顶为左括号，则直接将运算符入栈。

- 如果运算符优先级高于栈顶运算符，则将运算符入栈。

- 否则，将栈顶运算符弹出并添加到后缀表达式中，直到栈为空或栈顶为左括号，然后将当前运算符入栈。

3. 扫描完中缀表达式后，将栈中剩余的运算符依次弹出并添加到后缀表达式中。

4. 后缀表达式即为转换后的逆波兰表达式。

下面是一个实现示例：

import java.util.Stack;

public class Calculator {
    // 运算符优先级
    private static final int ADD_PRIORITY = 1;
    private static final int SUB_PRIORITY = 1;
    private static final int MUL_PRIORITY = 2;
    private static final int DIV_PRIORITY = 2;

    public static void main(String[] args) {
        String expression = "3+4*5-2/2";
        int result = calculate(expression);
        System.out.println(result); // 输出 19
    }

    // 计算逆波兰表达式
    public static int calculate(String expression) {
        String[] tokens = expression.split("\\s+");
        Stack<Integer> stack = new Stack<>();
        for (String token : tokens) {
            if (isNumber(token)) {
                stack.push(Integer.parseInt(token));
            } else {
                int b = stack.pop();
                int a = stack.pop();
                switch (token) {
                    case "+":
                        stack.push(a + b);
                        break;
                    case "-":
                        stack.push(a - b);
                        break;
                    case "*":
                        stack.push(a * b);
                        break;
                    case "/":
                        stack.push(a / b);
                        break;
                }
            }
        }
        return stack.pop();
    }

    // 将中缀表达式转换为逆波兰表达式
    public static String infixToPostfix(String expression) {
        String[] tokens = expression.split("\\s+");
        Stack<String> stack = new Stack<>();
        StringBuilder postfix = new StringBuilder();
        for (String token : tokens) {
            if (isNumber(token)) {
                postfix.append(token).append(" ");
            } else if (isOperator(token)) {
                while (!stack.isEmpty() && isOperator(stack.peek()) && comparePriority(token, stack.peek()) <= 0) {
                    postfix.append(stack.pop()).append(" ");
                }
                stack.push(token);
            } else if (token.equals("(")) {
                stack.push(token);
            } else if (token.equals(")")) {
                while (!stack.isEmpty() && !stack.peek().equals("(")) {
                    postfix.append(stack.pop()).append(" ");
                }
                stack.pop();
            }
        }
        while (!stack.isEmpty()) {
            postfix.append(stack.pop()).append(" ");
        }
        return postfix.toString();
    }

    // 判断字符串是否表示数字
    private static boolean isNumber(String str) {
        try {
            Integer.parseInt(str);
            return true;
        } catch (NumberFormatException e) {
            return false;
        }
    }

    // 判断字符串是否表示运算符
    private static boolean isOperator(String str) {
        return str.equals("+") || str.equals("-") || str.equals("*") || str.equals("/");
    }

    // 比较两个运算符的优先级，返回值为正数表示第一个运算符优先级高，为负数表示第二个运算符优先级高，为0表示两个运算符优先级相等
    private static int comparePriority(String op1, String op2) {
        int priority1 = getPriority(op1);
        int priority2 = getPriority(op2);
        return priority1 - priority2;
    }

    // 获取运算符的优先级
    private static int getPriority(String op) {
        switch (op) {
            case "+":
                return ADD_PRIORITY;
            case "-":
                return SUB_PRIORITY;
            case "*":
                return MUL_PRIORITY;
            case "/":
                return DIV_PRIORITY;
            default:
                throw new IllegalArgumentException("Invalid operator: " + op);
        }
    }
}