计算器实现代码

import java.util.Scanner;
import java.util.Stack;

public class Calculator {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("简易计算器（支持 +、-、*、/、()，输入 'exit' 退出）");
        while (true) {
            System.out.print("请输入表达式：");
            String expression = scanner.nextLine().trim();
            
            if ("exit".equalsIgnoreCase(expression)) {
                System.out.println("退出计算器");
                break;
            }
            
            try {
                double result = calculate(expression);
                System.out.println("计算结果：" + result + "\n");
            } catch (Exception e) {
                System.out.println("计算错误：" + e.getMessage() + "\n");
            }
        }
        scanner.close();
    }

    /**
     * 计算表达式结果
     */
    private static double calculate(String expression) {
        // 去除空格
        expression = expression.replaceAll(" ", "");
        if (expression.isEmpty()) {
            throw new IllegalArgumentException("表达式不能为空");
        }

        Stack<Double> numStack = new Stack<>(); // 数字栈
        Stack<Character> opStack = new Stack<>(); // 运算符栈

        for (int i = 0; i < expression.length(); i++) {
            char c = expression.charAt(i);

            // 处理数字（包括多位数和负数）
            if (Character.isDigit(c) || (c == '-' && (i == 0 || isOperator(expression.charAt(i - 1)) || expression.charAt(i - 1) == '('))) {
                StringBuilder numStr = new StringBuilder();
                numStr.append(c); // 负数的负号

                // 继续读取后续数字或小数点
                while (i + 1 < expression.length() && (Character.isDigit(expression.charAt(i + 1)) || expression.charAt(i + 1) == '.')) {
                    numStr.append(expression.charAt(++i));
                }

                // 解析数字并入栈
                numStack.push(Double.parseDouble(numStr.toString()));
            }
            // 处理左括号
            else if (c == '(') {
                opStack.push(c);
            }
            // 处理右括号：计算括号内的表达式
            else if (c == ')') {
                while (opStack.peek() != '(') {
                    calculateTop(numStack, opStack);
                }
                opStack.pop(); // 弹出左括号
            }
            // 处理运算符
            else if (isOperator(c)) {
                // 栈顶运算符优先级高于当前运算符时，先计算
                while (!opStack.isEmpty() && opStack.peek() != '(' && priority(opStack.peek()) >= priority(c)) {
                    calculateTop(numStack, opStack);
                }
                opStack.push(c);
            } else {
                throw new IllegalArgumentException("不支持的字符：" + c);
            }
        }

        // 处理剩余运算符
        while (!opStack.isEmpty()) {
            if (opStack.peek() == '(') {
                throw new IllegalArgumentException("括号不匹配");
            }
            calculateTop(numStack, opStack);
        }

        if (numStack.size() != 1) {
            throw new IllegalArgumentException("表达式格式错误");
        }

        return numStack.pop();
    }

    /**
     * 计算栈顶的运算符和数字
     */
    private static void calculateTop(Stack<Double> numStack, Stack<Character> opStack) {
        if (numStack.size() < 2) {
            throw new IllegalArgumentException("表达式格式错误");
        }
        double b = numStack.pop();
        double a = numStack.pop();
        char op = opStack.pop();
        double result = 0;

        switch (op) {
            case '+':
                result = a + b;
                break;
            case '-':
                result = a - b;
                break;
            case '*':
                result = a * b;
                break;
            case '/':
                if (b == 0) {
                    throw new ArithmeticException("除数不能为0");
                }
                result = a / b;
                break;
            default:
                throw new IllegalArgumentException("不支持的运算符：" + op);
        }
        numStack.push(result);
    }

    /**
     * 判断是否为运算符
     */
    private static boolean isOperator(char c) {
        return c == '+' || c == '-' || c == '*' || c == '/';
    }

    /**
     * 定义运算符优先级：乘除 > 加减
     */
    private static int priority(char op) {
        if (op == '+' || op == '-') {
            return 1;
        } else if (op == '*' || op == '/') {
            return 2;
        }
        return 0;
    }
}