Java代码 - 求解四则运算表达式

【Java实现】 输出代码，求解10以内整数的四则运算表达式。实现思路就是使用一个数字栈存储表达式中遍历的数字，一个符号栈存储表达式中的符号，根据符号的优先级，判断是符号入栈，还是进行运算，具体的代码实现如下：

public static void main(String[] args) {
   String expression = "9-2*(4+6/2)*2";
    // 数字栈
    LinkedList<Integer> intStack = new LinkedList<>();
    // 符号栈
    LinkedList<Character>  charStack = new LinkedList<>();

    // 去掉表达式左右多余的空格
    expression = expression.trim();
    // 开始遍历表达式的每一个字符
    for (int i = 0; i < expression.length(); i++) {
        // 表达是中间有多余空格，直接跳过
        if(Character.isSpaceChar(expression.charAt(i))){
            continue;
        }
        if(Character.isDigit(expression.charAt(i))){
            // 数字直接入数字栈
            intStack.push(expression.charAt(i) - '0');
        } else {
            // 符号栈为空，直接把符号入栈
            if(charStack.isEmpty()){
                charStack.push(expression.charAt(i));
            } else {
                // 拿当前符号和栈顶元素的符号比较优先级了
                for(;;){
                    if(comparePriority(expression.charAt(i), charStack.peek())){
                        // 当前遍历的符号优先级大，直接入符号栈
                        charStack.push(expression.charAt(i));
                        break;
                    } else {
                        // 从符号栈里面出一个符号
                        char sign = charStack.pop();
                        // 如果遇到左括号，符号栈的符号处理完成
                        if(sign == '('){
                            break;
                        }

                        // 从数字栈里面出两个数字
                        int right = intStack.pop();
                        int left = intStack.pop();

                        // 计算出运算结果，直接入数字栈
                        intStack.push(caculate(left, sign, right));

                        if(charStack.isEmpty()){
                            // 当前符号比栈中所有的符号的优先级都<=，符号栈的符号出完了
                            charStack.push(expression.charAt(i));
                            break;
                        }
                    }
                }
            }
        }
    }

    // 如果一直出现优先级大的符号，则上面的循环退出，需要把符号栈里面的符号全部计算完成
    while(!charStack.isEmpty()){
        char sign = charStack.pop();

        // 从数字栈里面出两个数字
        int right = intStack.pop();
        int left = intStack.pop();

        // 计算出运算结果，直接入数字栈
        intStack.push(caculate(left, sign, right));
    }

    System.out.println(expression + "的运算结果是:" + intStack.peek());
}

/**
 * 根据传入的sign运算符号，计算操作数的结果
 * @param left
 * @param sign
 * @param right
 * @return
 */
private static int caculate(int left, char sign, int right) {
    switch (sign){
        case '+':
            return left + right;
        case '-':
            return left - right;
        case '*':
            return left * right;
        case '/':
            return left / right;
    }
    return 0;
}

/**
 * 比较ch1和ch2的符号优先级
 * @param ch1
 * @param ch2
 * @return true:ch1 > ch2   false: ch1 <= ch2
 */
private static boolean comparePriority(char ch1, Character ch2) {
    switch (ch1){
        case '(':
            return true;
        case ')':
            return false;
        case '+':
        case '-':
            switch (ch2){
                case '+':
                case '-':
                case '*':
                case '/':
                    return false;
                case '(':
                    return true;
            }
            break;
        case '*':
        case '/':
            switch (ch2){
                case '+':
                case '-':
                case '(':
                    return true;
                case '*':
                case '/':
                    return false;
            }
            break;
    }
    return false;
}