Idea执行Pom.xml导入jar包提示sun.misc.BASE64Encoder jar找不到---SpringCloud工作笔记197

支持加减乘除及括号运算

public class Calculator {

    private static final char ADD_OPER = '+';
    private static final char SUB_OPER = '-';
    private static final char MUL_OPER = 'x';
    private static final char DIV_OPER = '/';
    private static final char LEFT_OPER = '(';
    private static final char RIGHT_OPER = ')';
    private static final String suffix = "+0";

    public static void main(String[] args) {
        Calculator calculator = new Calculator();
         System.out.println(calculator.cal("-23+48x7-(8+78x9/3)+8/4-8"));//65
    }


    public int cal(String expression) {
        // 处理表达式
        expression = handleExpression(expression);
        LinkedList<Integer> numStack = new LinkedList<>(); //数字栈
        LinkedList<Character> operStack = new LinkedList<>(); //符号栈
        int index = 0; // 指针，指向表达式的位置
        String num = ""; // 处理多位数
        while (true) {
            char ch = expression.charAt(index);
            if (isOper(ch)) { // 运算符
                // 符号栈不为空，且当前运算符优先级大于等于栈顶运算符
                if (!operStack.isEmpty() && priority(operStack.peekLast()) >= priority(ch)) {
                    int calVal = calculate(numStack.removeLast(), numStack.removeLast(), operStack.removeLast());
                    numStack.addLast(calVal);
                }
                operStack.addLast(ch);
                index++;
            } else if (isParentheses(ch)) { // 括号
                int begin = index, end = index;
                while (expression.charAt(index) != RIGHT_OPER) {
                    index++;
                }
                end = index;
                // 计算括号里的表达式
                int cal = cal(expression.substring(begin + 1, end));
                numStack.addLast(cal);
                index++;
            } else { // 数字
                num = num + ch;
                // 到达表达式结尾，结束循环
                if (index == expression.length() - 1) {
                    numStack.addLast(Integer.parseInt(num));
                    break;
                }
                // 下一位不是数字，将当前值压如数字栈
                if (!isNumber(expression.charAt(index + 1))) {
                    numStack.addLast(Integer.parseInt(num));
                    num = "";
                }
                index++;
            }
        }

        // 从前往后遍历，进行加/减运算，此时符号栈只有加/减
        int calVal = numStack.remove();
        while (true) {
            if (operStack.isEmpty()) {
                break;
            }
            if (operStack.remove().charValue() == ADD_OPER) {
                calVal = calVal + numStack.remove();
            } else if (operStack.remove().charValue() == SUB_OPER) {
                calVal = calVal - numStack.remove();
            }

        }
        return calVal;
    }

    public String handleExpression(String expression) {
        char ch = expression.charAt(0);
        if (ch == ADD_OPER || ch == SUB_OPER) { // 防止表达式首字符为运算式
            expression = "0" + expression;
        }
        expression = expression + suffix; // 防止 4+5/2，会先计算4+5
        return expression;
    }


    /**
     * 加减乘除的优先级
     * @param oper 运算符
     * @return
     */
    private int priority(char oper){
        if(oper == MUL_OPER || oper == DIV_OPER){
            return 1;
        }else if(oper == ADD_OPER || oper == SUB_OPER){
            return 0;
        }else {
            return -1;
        }
    }

    /**
     * 按出栈顺序进行运算
     * @param num1
     * @param num2
     * @param oper
     * @return
     */
    private int calculate(int num1, int num2, char oper){
        int result = 0;
        switch (oper){
            case ADD_OPER:
                result = num1 + num2;
                break;
            case SUB_OPER:
                result = num2 - num1;
                break;
            case MUL_OPER:
                result = num1 * num2;
                break;
            case DIV_OPER:
                result = num2 / num1;
                break;
            default:
                break;
        }
        return result;
    }

    private boolean isNumber(char ch) {
        if (ch >= '0' && ch <= '9') {
            return true;
        }
        return false;
    }

    /**
     * 是否为运算符
     * @param ch 运算符
     * @return
     */
    private boolean isOper(char ch) {
        return ch == ADD_OPER || ch == SUB_OPER || ch == MUL_OPER || ch == DIV_OPER;
    }

    /**
     * 是否为括号
     * @param ch
     * @return
     */
    private boolean isParentheses(char ch){
        return ch == LEFT_OPER || ch == RIGHT_OPER;
    }
}