求解四则运算表达式的值

class SeqStack<T> {
    private T[] stack;
    private int top;

    public SeqStack() {
        this(10);
    }

    public SeqStack(int size) {
        this.stack = (T[]) new Object[size];
        this.top = 0;
    }

    public void push(T val) {
        if (full()) {
            this.stack = Arrays.copyOf(this.stack, this.stack.length * 2);
        }
        this.stack[this.top] = val;
        this.top++;
    }
    public void pop() {
        if (empty())
            return;
        this.top--;
        if (this.top < this.stack.length / 2) {
            this.stack = Arrays.copyOf(this.stack, this.stack.length / 2);
        }
    }
    public T top () {
        return this.stack[this.top-1];
    }
    public boolean full () {
        return this.top == this.stack.length;
    }
    public boolean empty () {
        return this.top == 0;
    }
}

public class calculation {

    /**
     * 描述: 输出代码，求解10以内的整数的四则运算表达式
     * 9-2*(4+6/3)*2+4/2
     *
     * @Author shilei
     * @Date 2019/4/27
     */
    public static void main(String[] args) {
        String expression = "9-2*4+6/3*2"; //  9,2,4  -,*   9-2*4+6/3*2+4/2
        // 请输出代码，把上面的四则运算表达式的结果计算出来并输出
        // 主要用到的就是栈结构

        // 数字栈
        SeqStack<Integer> intStack = new SeqStack<>();
        // 符号栈
        SeqStack<Character>  charStack = new SeqStack<>();

        char[] express = expression.toCharArray();

        // 开始遍历表达式的每一个字符
        for (int i = 0; i < express.length; i++) {

            if(Character.isDigit(express[i])){
                // 数字
                intStack.push(express[i] - '0'); // '9'-'0' = 9 (int)'0'  48
            } else {
                // 符号
                if(charStack.empty()){ // 把第一个遍历的符号直接入栈就可以
                    charStack.push(express[i]);
                } else {
                    // 拿当前符号和栈顶元素的符号比较优先级了  express[i]  charStack.top()
                    for(;;){
                        if(comparePriority(express[i], charStack.top())){
                            // express[i] > charStack.top()
                            charStack.push(express[i]);
                            break;
                        } else {
                            // express[i] + - <= charStack.top() * /
                            // 从符号栈里面出一个符号
                            char sign = charStack.top();
                            charStack.pop();

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

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

                            if(charStack.empty()){
                                // 当前符号比栈中所有的符号的优先级都<=
                                charStack.push(express[i]);
                                break;
                            }
                        }
                    }
                }
            }
        }

        // 上面的循环，理想的情况就是把结果都计算完了
        while(!charStack.empty()){
            char sign = charStack.top();
            charStack.pop();

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

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

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


    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 '+':
                case '-':
                    switch (ch2){
                        case '+':
                        case '-':
                        case '*':
                        case '/':
                            return false;
                    }
                    break;
                case '*':
                case '/':
                    switch (ch2){
                        case '+':
                        case '-':
                            return true;
                        case '*':
                        case '/':
                            return false;
                    }
                    break;
            }
            return false;
        }
    }