中缀表达式

    或中缀记法：是一个通用的算术或逻辑公式表示方法， 操作符是以中缀形式处于操作数的中间（例：3 + 4），中缀表达式是人们常用的算术表示方法。
    与前缀表达式（例：+ 3 4）或后缀表达式（例：3 4 +）相比，中缀表达式不容易被计算机解析，但仍被许多程序语言使用，因为它符合人们的普遍用法。
    与前缀或后缀记法不同的是，中缀记法中括号是必需的。计算过程中必须用括号将操作符和对应的操作数括起来，用于指示运算的次序。

例如有这样一个字符串表达式:"(10+20/2*3)/2+8"
        首先对它的运算符和提高优先级符号"()“的左右进行添加” "(空格)的操作，然后在运用java的split方法切割 ，就能实现对表达式的符号数字的分类识别，最后再用两个ArrayStack存放操作符和数字，最后根据不同的操作符与操作符栈栈顶遇到的几种情况分类，最后再书写每次计算，弹两个数字和一个操作符，结果放入数字栈的方法实现一个式子的计算。

 public static void main(String[] args) {
        String expression = "(10+20/2*3)/2+8";
        expression = FormatExpreesion(expression);     //对表达式进行格式化
        int result = EvulateExpression(expression);    //对格式化之后的等式进行计算
        System.out.println(result);                    //输出结果
    }

    private static int EvulateExpression(String expression) {
        ArrayStack<Character> opertorStack = new ArrayStack<>();    //操作符栈 用来存放操作符
        ArrayStack<Integer> numberStack = new ArrayStack<>();       //数字栈 存放数字

        String[] tokens = expression.split(" ");              //用" "对格式化之后的表达式进行切割
        for (String token : tokens) {                               //遍历token
            if (token.length() == 0) {
                continue;
            } else if (token.charAt(0) == '+' || token.charAt(0) == '-') {    //当遇到加减时
                while (!opertorStack.isEmpty() && (opertorStack.peek() == '+' || opertorStack.peek() == '-'
                        || opertorStack.peek() == '*'
                        || opertorStack.peek() == '/')) {
                    processAnOperator(opertorStack, numberStack);
                }
                opertorStack.push(token.charAt(0));
            } else if (token.charAt(0) == '*' || token.charAt(0) == '/') {     //当遇到乘除
                while (!opertorStack.isEmpty() && (opertorStack.peek() == '*' || opertorStack.peek() == '/')) {
                    processAnOperator(opertorStack, numberStack);
                }
                opertorStack.push(token.charAt(0));
            } else if (token.charAt(0) == '(') {                               //左括号
                opertorStack.push(token.charAt(0));
            } else if (token.charAt(0) == ')') {                               //右括号
                while (opertorStack.peek() != '(') {
                    processAnOperator(opertorStack, numberStack);
                }
                opertorStack.pop();
            } else {
                numberStack.push(new Integer(token));
            }
        } while(!opertorStack.isEmpty()){                                     //确保数字栈空
            processAnOperator(opertorStack, numberStack);
        }
        return numberStack.pop();
    }

    private static void processAnOperator(ArrayStack<Character> opertorStack, ArrayStack<Integer> numberStack) {
        //这个方法用来计算
        int num1 = numberStack.pop();
        int num2 = numberStack.pop();
        char c = opertorStack.pop();
        switch (c) {
            case '+':
                numberStack.push(num2 + num1);
                break;
            case '-':
                numberStack.push(num2 - num1);
                break;
            case '*':
                numberStack.push(num2 * num1);
                break;
            case '/':
                numberStack.push(num2 / num1);
                break;

        }
    }

    private static String FormatExpreesion(String expression) {
        //用来格式化表达式
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < expression.length(); i++) {
            char c = expression.charAt(i);
            if (c == '(' || c == ')' || c == '+' || c == '-' || c == '*' || c == '/') {
                sb.append(' ');
                sb.append(c);
                sb.append(' ');
            } else {
                sb.append(c);
            }
        }
        return sb.toString();
    }