模拟计算器java

以下是一个模拟计算器的 Java 代码示例，利用了栈的数据结构实现了四则运算：

import java.util.*;

public class Calculator {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.print("请输入待计算的表达式: ");
        String expression = input.nextLine();
        List<String> postfixExpression = infixToPostfix(expression); // 将中缀表达式转换成后缀表达式
        double result = evaluatePostfix(postfixExpression); // 计算后缀表达式的值
        System.out.println("计算结果为: " + result);
    }

    // 将中缀表达式转换成后缀表达式
    public static List<String> infixToPostfix(String expression) {
        List<String> postfixExpression = new ArrayList<>();
        Stack<String> operatorStack = new Stack<>();
        String[] tokens = expression.split("\\s+"); // 通过空格分隔字符串，得到运算符和操作数
        for (String token : tokens) {
            if (token.matches("\\d+(\\.\\d+)?")) { // 如果是数字，直接加入后缀表达式列表
                postfixExpression.add(token);
            } else if (token.equals("(")) { // 如果是左括号，入栈
                operatorStack.push(token);
            } else if (token.equals(")")) { // 如果是右括号，将栈顶的运算符全部弹出并加入后缀表达式列表
                while (!operatorStack.isEmpty() && !operatorStack.peek().equals("(")) {
                    postfixExpression.add(operatorStack.pop());
                }
                operatorStack.pop(); // 弹出左括号
            } else { // 如果是运算符
                while (!operatorStack.isEmpty() && getPrecedence(operatorStack.peek()) >= getPrecedence(token)) {
                    postfixExpression.add(operatorStack.pop()); // 弹出优先级高于或等于当前运算符的所有运算符，并加入后缀表达式列表
                }
                operatorStack.push(token); // 将当前运算符入栈
            }
        }
        while (!operatorStack.isEmpty()) {
            postfixExpression.add(operatorStack.pop()); // 将剩余的运算符全部弹出并加入后缀表达式列表
        }
        return postfixExpression;
    }

    // 计算后缀表达式的值
    public static double evaluatePostfix(List<String> postfixExpression) {
        Stack<Double> operandStack = new Stack<>();
        for (String token : postfixExpression) {
            if (token.matches("\\d+(\\.\\d+)?")) { // 如果是数字，入栈
                operandStack.push(Double.parseDouble(token));
            } else { // 如果是运算符，弹出两个操作数进行计算，并将结果入栈
                double operand2 = operandStack.pop();
                double operand1 = operandStack.pop();
                switch (token) {
                    case "+":
                        operandStack.push(operand1 + operand2);
                        break;
                    case "-":
                        operandStack.push(operand1 - operand2);
                        break;
                    case "*":
                        operandStack.push(operand1 * operand2);
                        break;
                    case "/":
                        operandStack.push(operand1 / operand2);
                        break;
                }
            }
        }
        return operandStack.pop(); // 返回最终结果
    }

    // 获取运算符的优先级
    public static int getPrecedence(String operator) {
        switch (operator) {
            case "+":
            case "-":
                return 1;
            case "*":
            case "/":
                return 2;
            default:
                return 0;
        }
    }
}

该程序通过将中缀表达式转换成后缀表达式，再计算后缀表达式的值，实现了模拟计算器的功能。可以根据需要对代码进行修改和扩展。