计算器模板

直接调用culcaltorMain（）方法即可，传入String参数列如:“2*3+（1-2）*5/8”，其它的代码都注释了，就不多说了

public static int culcaltorMain(String s) {
        String trim = s.replaceAll(" ", "");
        List<String> s1 = stringToList(trim);
        if (!s1.contains("*")&&!s1.contains("-")&&!s1.contains("/")&&!s1.contains("+")){
            String s2 = trim.replaceAll("\\(", "");
            String s3 = s2.replaceAll("\\)", "");
            return Integer.parseInt(s3);
        }
        List<String> s2 = infixToSufix(s1);
        int n = calculator(s2);
        return n;
    }


    /**
     * 将String字符串转化为List集合
     *
     * @param s 需要转化的字符串
     * @return 转化后的list集合
     */
    public static List<String> stringToList(String s) {
        List<String> sList = new ArrayList<>();
        //循环判断每一个字符
        for (int i = 0; i < s.length(); ++i) {
            char c = s.charAt(i);
            //如果是运算符直接加进去即可,i!=0的含义是第一个肯定是数字，如果第一个是操作符的话说明第一个数是负数
           if (judgeOperator(c + "")&&i==0?c=='-'?false:true:true) {
                sList.add(c + "");
            } else {
                //如果是数字的话，需要看看是不是多位数
                String num = s.charAt(i) + "";
                while (true) {
                    if (i + 1 < s.length() && !judgeOperator(s.charAt(i + 1) + "")) {
                        num += s.charAt(i + 1);
                        i++;
                    } else {
                        break;
                    }
                }
                sList.add(num);
            }
        }
        return sList;
    }


    /**
     * 判断是不是运算符或者括号
     *
     * @param s 需要判断的字符
     * @return 字符是否为
     */
    public static boolean judgeOperator(String s) {
        if (s.equals("*") || s.equals("/") || s.equals("+") || s.equals("-") || s.equals("(") || s.equals(")")) {
            return true;
        }
        return false;
    }


    /**
     * 将中缀表达式的集合 转化为 后缀表达式的集合
     *
     * @param list 需要转化的中缀表达式
     * @return 后缀表达式集合
     */
    public static List<String> infixToSufix(List<String> list) {
        Stack<String> numStack = new Stack<>();
        Stack<String> operatorStack = new Stack<>();

        /**
         * 将中缀表达式转化为后缀表达式
         * 1.判断是不是数字，如果是数字直接加入数字栈中
         * 2.如果不是数字，就是操作符
         * 3.若操作符栈为空，则直接将运算符加入到操作符栈中
         * 4.若是“）”,将操作符栈中的操作符依次取出，直到取出“（”为止
         * 5.若不是“（”，“）”，则判断当前操作符的优先级是否比操作符栈顶元素高，如果高则加入操作符栈中
         * 6.若操作符比操作符栈的栈顶元素的优先级低或相等，则取出操作符栈顶的操作符加入到数字栈中
         * 7.并将这个操作符加入到操作符栈
         */
        for (String s : list) {

            //如果是操作符的话
            if (judgeOperator(s)) {
                if (operatorStack.isEmpty()) {
                    operatorStack.add(s);
                } else if (s.equals("(")) {
                    operatorStack.add(s);
                } else if (s.equals(")")) {
                    while (!operatorStack.peek().equals("(")) {
                        numStack.add(operatorStack.pop());
                    }
                    operatorStack.pop();
                } else {
                    if (operatorPriority(s) > operatorPriority(operatorStack.peek())) {
                        operatorStack.add(s);
                    } else {
                        numStack.add(operatorStack.pop());
                        operatorStack.add(s);
                    }
                }
            } else {
                numStack.add(s);
            }
        }
        while (!operatorStack.isEmpty()) {
            numStack.add(operatorStack.pop());
        }
        return numStack;
    }

    /**
     * 判断操作符的优先级
     *
     * @param s 需要判断的操作符
     * @return 返回优先级
     */
    public static int operatorPriority(String s) {
        int priority;
        switch (s) {
            case "*":
            case "/":
                priority = 2;
                break;
            case "+":
            case "-":
                priority = 1;
                break;
            default:
                priority = 0;
        }
        return priority;
    }


    public static int calculator(List<String> list) {
        Stack<Integer> numStack = new Stack<>();
        for (String s : list) {
            if (judgeOperator(s)) {
                int calculate = calculate(numStack.pop(), numStack.pop(), s);
                numStack.add(calculate);
            } else {
                numStack.add(Integer.parseInt(s));
            }
        }
        return numStack.pop();
    }


    public static int calculate(int n1, int n2, String s) {
        int num = 0;
        switch (s) {
            case "*":
                num = n1 * n2;
                break;
            case "/":
                num = n2 / n1;
                break;
            case "+":
                num = n1 + n2;
                break;
            case "-":
                num = n2 - n1;
                break;
            default:
                num = 0;
        }
        return num;
    }