中缀表达式计算器

接前俩篇动态数组的博客内的代码实现的！！！！

package p3.实例应用;

import p2.线性结构.ArrayStack;

import javax.swing.text.StyledEditorKit;

/**
 * @Auther: wjw
 * @Date: 2022/1/10-01-10-16:53
 * @Description: p3.实例应用
 * @version: 1.0
 */
//中缀表达式且只适用于四则运算的计算器，
public class InfixCalculator {
    public static void main(String[] args) {
        //1、定义表达式
        String expression = "(10+20/2*3)/2+8";
        //最后抛出表达式异常
        try {
            //计算表达式的值
            int result = evaluateExpression(expression);
            System.out.println(result);
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("wrong expression" + expression);
        }


    }

    private static int evaluateExpression(String expression) {
        //需要俩个辅助栈
        ArrayStack<Character> operatorStack = new ArrayStack<>();
        ArrayStack<Integer> numberStack = new ArrayStack<>();
        //2、格式化表达式,对原表达式进行格式化处理，给所有非字符串俩边添加空格
        expression = insertBlanks(expression);
        //用split的方法,以空格为单位对字符串进行切割，并返回字符串数组
        String[] tokens = expression.split(" ");
        // 遍历字符串数组
        for (String token : tokens) { //token == tokens[i];
            //过滤空串
            if (token.length() == 0) {
                continue;
                //如果是加减
            } else if (token.charAt(0) == '+' || token.charAt(0) == '-') {
                //考虑到加减乘除的优先级
                //直到之前不是空或者栈顶不为+-*/ 则结束
                while (!operatorStack.isEmpty() && (operatorStack.peek() == '+' || operatorStack.peek() == '-' || operatorStack.peek() == '*' || operatorStack.peek() == '/')) {
                    //如果之前是+—*/ 需要弹栈进行计算
                    processAnOperator(numberStack, operatorStack);
                }
                //如果操作符栈为空 或者 栈顶为（ 进行压栈
                operatorStack.push(token.charAt(0));
                //如果是乘除
            } else if (token.charAt(0) == '*' || token.charAt(0) == '/') {
                while (!operatorStack.isEmpty() && (operatorStack.peek() == '*' || operatorStack.peek() == '/')) {
                    //如果之前是*/ 需要弹栈进行计算
                    processAnOperator(numberStack, operatorStack);
                }
                //如果操作符栈为空 或者 栈顶为（ 进行压栈
                operatorStack.push(token.charAt(0));
                //如果遍历到（那么继续压栈
            } else if (token.equals("(")) {
                operatorStack.push(token.charAt(0));
            } else if (token.equals(")")) {
                //只要操作符栈顶不是(就直接挨个弹栈进行计算
                while (operatorStack.peek() != '(') {
                    processAnOperator(numberStack, operatorStack);
                }
                //最后要清掉(
                operatorStack.pop();
                //遍历到数字，直接进数字栈
            } else {
                //将其字符串转换为数字
                numberStack.push(Integer.parseInt(token));
            }
        }
        //处理最后的操作符
        while (!operatorStack.isEmpty()) {
            processAnOperator(numberStack, operatorStack);
        }
        return numberStack.pop();
    }

    //操作符栈弹一个元素，数字栈弹俩个元素，进行计算，并将计算结果进栈到数字栈
    private static void processAnOperator(ArrayStack<Integer> numberStack, ArrayStack<Character> operatorStack) {
        char op = operatorStack.pop();
        int num1 = numberStack.pop();
        int num2 = numberStack.pop();
        //先弹一个数字放后面，后弹一个数字放前面，弹出来的操作符放中间
        //num2 op num1
        if (op == '+') {
            numberStack.push(num2 + num1);
        } else if (op == '-') {
            numberStack.push(num2 - num1);
        } else if (op == '*') {
            numberStack.push(num2 * num1);
        } else {
            numberStack.push(num2 / num1);
        }
    }

    //对原表达式进行格式化处理，给所有非字符串俩边添加字符
    private static String insertBlanks(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();
    }
}