用栈实现表达式计算

public class Calculator {

    public static void main(String[] args) {
        System.out.println("*******************");
        //测试计算是否正确
//        String express = "1+2*3-4";     //测试结果为3，正确
        String express = "10*3+4*21/3-15+6*2"; //测试结果为55，正确
//        String express = "70+2*6-4";        //测试结果为78，正确
        int result = handle(express);
        System.out.println("计算的结果是：" + result);
    }

    public static int handle(String express) {
        //数字栈
        ArrayStack numStack = new ArrayStack(10);
        //操作符栈
        ArrayStack opeStack = new ArrayStack(10);
        String keepNum = "";    //用于拼接多位数
        int index = 0;  //索引值
        int num1 = 0;
        int num2 = 0;
        int result = 0;
        char cur = ' '; //索引值所对应的字符
        while (true) {
            cur = express.substring(index, index + 1).charAt(0);
            //判断当前字符是否是运算符，如果不是，则直接压入数字栈
            if (isOperator(cur)) {
                //判断运算符栈是否为空，空则直接加入栈，否则判断当前运算符的优先级是否小于等于栈顶运算符的优先级；
                //如果小于等于，则进行运算
                //否则直接把当前运算符压入栈顶
                if (!opeStack.isEmpty()) {
                    if (priority(cur) <= priority(opeStack.peek())) {
                        num1 = numStack.pop();
                        num2 = numStack.pop();
                        int operator = opeStack.pop();
                        result = calcualte(num1, num2, operator);
                        numStack.push(result);
                        opeStack.push(cur);
                    } else {
                        opeStack.push(cur);
                    }
                } else {
                    opeStack.push(cur);
                }
            } else {
                //当处理多位数时，不能发现是一个数就立即入栈，因为可能是多位数
                //需要向express的表达式的index往后再看一位，如果是数就进行扫描，如果是符号就入栈
                if (index == express.length() - 1) {
                    numStack.push(cur - 48);
                } else {
                    keepNum = keepNum + cur;
                    char next = express.substring(index + 1, index + 2).charAt(0);
                    while (!isOperator(next)) {
                        keepNum = keepNum + next;
                        index++;
                        next = express.substring(index + 1, index + 2).charAt(0);
                    }
                    int num = Integer.parseInt(keepNum);
                    keepNum = "";
                    numStack.push(num);
                }
            }
            index++;
            if (index >= express.length()) {
                break;
            }
        }
        int operator = 0;
        while (true) {
            if (opeStack.isEmpty()) {
                break;
            }
            num1 = numStack.pop();
            num2 = numStack.pop();
            operator = opeStack.pop();
            result = calcualte(num1, num2, operator);
            numStack.push(result);
        }
        //数字栈留下的最后一个元素，即为运算的结果
        return numStack.peek();
    }

    /**
     * 对出栈的元素进行计算
     *
     * @param num1     第一个出栈的数字
     * @param num2     第二个出栈的数字
     * @param operator 出栈的运算符
     * @return 返回运算的结果
     */
    public static int calcualte(int num1, int num2, int operator) {
        int result = 0;
        switch (operator) {
            case '+':
                result = num1 + num2;
                break;
            case '-':
                result = num2 - num1;
                break;
            case '*':
                result = num1 * num2;
                break;
            case '/':
                result = num2 / num1;
                break;
            default:
                System.out.println("出现了异常的运算符");
                result = -1;
        }
        return result;
    }

    /**
     * 获取当前运算符的优先级
     *
     * @param operator 运算符
     * @return 返货运算符的优先级
     */
    public static int priority(int operator) {
        if (operator == '*' || operator == '/') {
            return 1;
        } else if (operator == '+' || operator == '-') {
            return 0;
        } else {
            return -1;
        }
    }

    /**
     * 判断当前索引的位置所对应的是否是操作符
     *
     * @param indexChar
     * @return 返回判断的结果
     */
    public static boolean isOperator(char indexChar) {
        return indexChar == '+' || indexChar == '-' || indexChar == '*' || indexChar == '/';
    }
}

class ArrayStack {
    private int maxSize;
    private int[] stack;
    private int top = -1;

    public ArrayStack(int maxSize) {
        this.maxSize = maxSize;
        stack = new int[this.maxSize];
    }

    public boolean isFull() {
        return top == maxSize - 1;
    }

    public boolean isEmpty() {
        return top == -1;
    }

    public int peek(){
        return stack[top];
    }

    public void push(int value) {
        if (isFull()) {
            System.out.println("栈满~");
            return;
        }
        stack[++top] = value;
    }

    public int pop() {
        if (isEmpty()) {
            throw new RuntimeException("栈空~");
        }
        return stack[top--];
    }

    public void show() {
        for (int i = top; i >= 0; i--) {
            System.out.printf("stack[%d]=%d\n", i, stack[i]);
        }
    }
}