处理负数运算 | #四则运算#

此计算器主要处理的难点在于负数和减号的区分，它通过在遇到乘号和除号后，根据下一个字符是否为'-'来判断是不是负数，并进行相应的操作，以此来实现对负数的处理。

能处理-2*-5 2*-5 -2*5 等三种带‘-’的情况

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            String s = sc.nextLine();
            // 将其他类型的括号替换成小括号，这样可以统一处理
            s = s.replace("{", "(");
            s = s.replace("[", "(");
            s = s.replace("}", ")");
            s = s.replace("]", ")");
            // 在字符串末尾添加"+"，为了处理最后一个数字
            s = s + "+";
            // 打印出结果
            System.out.println(slove(s, 0, s.length() - 1));
        }
    }

    public static int slove(String s, int l, int r) {

        Stack<Integer> stack = new Stack<>();
        char[] chs = s.toCharArray();
        int fu = 1;
        // 初始化操作符为'+'
        char sign = '+';
        // 初始化数字为0
        int number = 0;
        // 遍历字符串中的每个字符
        for (int i = 0; i <= r; i++) {

            char ch = chs[i];
            // 如果当前字符是空格，则跳过
            if (ch == ' ') continue;
            // 如果当前字符是数字，则拼接数字
            if (Character.isDigit(ch)) {
                number = number * 10 + ch - '0';
            }
            // 对负数进行处理
            number = fu * Math.abs(number) ;
            // 如果当前字符是'('，说明遇到了一个子表达式
            if (ch == '(') {
                // 找到子表达式的右括号的位置
                int j = i;
                int count = 0;
                for (; i < s.length(); i++) {
                    if (chs[i] == ')') count--;
                    if (chs[i] == '(') count++;
                    // 当遇到的左右括号数量相等时，说明找到了子表达式的右括号
                    if (count == 0) break;
                }
                // 递归处理子表达式
                number = slove(s.substring(j + 1, i) + "+", 0, i - j - 1);
            }
            // 如果当前字符不是数字
            if (!Character.isDigit(ch)) {
                // 根据操作符对数字进行处理，并将结果压入栈
                switch (sign) {
                    case '+':
                        stack.push(number);
                        fu = 1;
                        break;
                    case '-':
                        stack.push(-1 * number);
                        fu = 1;
                        break;
                    case '*':
                        // 处理'-'为负号的情况
                        if (ch == '-' && chs[i - 1] == '*') {
                            fu = -1;
                            continue;
                        } else {
                            stack.push(stack.pop() * number);
                            fu = 1;
                        }
                        break;
                    case '/':
                        // 处理'-'为负号的情况
                        if (ch == '-' && chs[i - 1] == '/') {
                            fu = -1;
                            continue;
                        } else if (stack.peek() != 0) {
                            stack.push(stack.pop() / number);
                            fu = 1;
                        }
                        break;
                }
                // 更新操作符和数字
                sign = ch;
                number = 0;
            }
        }
        // 最后，把栈中的所有数字求和，就得到了最后的结果
        int total = 0;
        while (!stack.isEmpty()) {
            total += stack.pop();
        }
        return total;
    }
}

}