题解 | #四则运算#

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Stack;

public class Main {
    public static void main(String[] args) {
        BufferedReader r = new BufferedReader(new InputStreamReader(System.in));
        String a;
        try {
            a = r.readLine();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        char[] chs = a.toCharArray();
        int i = 0, j, l = chs.length;
        int c1;
        float n1, n2, t;
        boolean minus;
        while (i < l) {//将所有的中括号、大括号替换为小括号
            if (chs[i] == '[' || chs[i] == '{') chs[i] = '(';
            if (chs[i] == ']' || chs[i] == '}') chs[i] = ')';
            i++;
        }
        Stack<Float> nums = new Stack<>();//初始化栈，存放数字
        Stack<Integer> calcs = new Stack<>();//初始化栈，存放符号
        i = 0;
        while (i < l) {
            if (chs[i] == '(') {//ASCII码40
                calcs.push((int) '(');
                i++;
                continue;
            }
            if (chs[i] == ')') {//ASCII码41
                while ((c1 = calcs.peek()) != '(') {//遇到反括回，两栈分别弹出运算符和数字进行计算，直到符号栈顶的元素是(；判断栈顶元素，因此用peek。
                    calcs.pop();
                    n2 = nums.pop();//最上面是n2
                    n1 = nums.pop();//其次是n1
                    t = cal(n1, n2, c1);//运算实质是n1?n2
                    nums.push(t);
                }
                calcs.pop();//计算完毕，将小正括号弹出，因为循环结束，符号栈calcs顶肯定是(
                i++;
                continue;
            }
            if (chs[i] == '+' || chs[i] == '*' || chs[i] == '/' || chs[i] == '-') {
                minus = chs[i] == '-' && i > 0 && chs[i - 1] == '(';
                minus = minus || i == 0 && chs[i] == '-';
                if (minus) nums.push(0f);
                if (calcs.isEmpty()) {//存储括号和运算符的栈是空
                    calcs.push((int) chs[i]);
                    i++;
                    continue;
                } else {//能逆向计算就将运算符存入，碰到反括回一起逆向计算，不能逆向计算就先算
                    c1 = calcs.peek();
                    if (c1 == '*' || c1 == '/' || (c1 == '-' && (chs[i] == '+' || chs[i] == '-'))) {
                        c1 = calcs.pop();
                        n2 = nums.pop();
                        n1 = nums.pop();
                        t = cal(n1, n2, c1);
                        nums.push(t);
                        continue;
                    }
                    calcs.push((int) chs[i]);
                    i++;
                    continue;
                    //------------------------------------------------------------------
                }
            }
            if ((chs[i] - '0' | '9' - chs[i]) > 0) {//遇到字符是数字，计算完整数字的大小
                j = i + 1;
                n1 = chs[i] - '0';
                while (j < l) {
                    if ((chs[j] - '0' | '9' - chs[j]) < 0) break;
                    n1 *= 10;
                    n1 += chs[j] - '0';
                    j++;
                }
                nums.push(n1);//将数字压入数字栈
                i = j;
                continue;
            }
            i++;
        }
        while (!calcs.isEmpty()) {//符号栈中还不是空的，逆向计算得到最后结果，此时符号栈中的运算符都是+和-
            c1 = calcs.pop();
            n2 = nums.pop();
            n1 = nums.pop();
            t = cal(n1, n2, c1);
            nums.push(t);
        }
        t = nums.pop();
        System.out.print(Math.round(t));//结果四舍五入
    }

    //计算方法，43——+，45——-，42——*，47——/，a和b分别为前面的数和后面的数
    private static float cal(float a, float b, int ope) {
        switch (ope) {
            case 43:
                return a + b;
            case 45:
                return a - b;
            case 42:
                return a * b;
            case 47:
                return a / b;
            default:
                return 0;
        }
    }
}