编辑代码

class Main {
	public static void main(String[] args) {
        //JSRUN引擎2.0，支持多达30种语言在线运行，全仿真在线交互输入输出。
		System.out.println("Hello world!   - java.jsrun.net ");
	}
}

import java.util.EmptyStackException;
//https://blog.csdn.net/weixin_46073538/article/details/126350966
public class Demo2 {
    public static void main(String[] args) {
        String exps = "12+8*9-9/3";
        //索引，用来读取字符串中的元素
        int index = 0;
        //保存读取到的数字和符号
        int number1 = 0;
        int number2 = 0;
        int thiChar = ' ';
        // 拼接字符串
        StringBuilder sb = new StringBuilder();
        // 数字栈
        ArrayStack numberStack = new ArrayStack(10);
        // 符号栈
        ArrayStack operationStack = new ArrayStack(10);
        // 保存计算结果
        int result;

        for (index = 0; index < exps.length(); index++) {
            thiChar = exps.charAt(index);
            // 判断字符是不是运算符
            if (operationStack.isOperation(thiChar)){
                // Todo 比较运算符之间的优先级
                if (operationStack.comparePriority(thiChar)){
                    // 入栈的运算符大于栈顶的，直接入栈
                    operationStack.push(thiChar);
                }else{
                    // 入栈的运算符小于栈顶的，将数字栈顶的两个元素进行入栈运算符计算
                    // 栈顶运算符
                    int popChar = operationStack.pop();
                    // 取出数字栈顶的两个元素
                    number2 = numberStack.pop();
                    number1 = numberStack.pop();
                    // 计算结果
                    result = operationStack.calculation(number1, number2, popChar);
                    // 将入栈的运算符入符号栈
                    operationStack.push(thiChar);
                    // 将计算的结果放入数字栈顶
                    numberStack.push(result);
                }
                // 数字直接添加到数字栈中
            }else{
                while (thiChar >= '0' && thiChar <= '9'){
                    // 数字有可能会是多为，12
                    sb.append(thiChar - '0');
                    System.out.println("拼接字符串"+sb);
                    index++;
                    // 到了最后一位结束
                    if (index >= exps.length()){
                        break;
                    }
                    thiChar = exps.charAt(index);
                }
                int num = Integer.parseInt(sb.toString());
                numberStack.push(num);
                // 初始化sb
                sb = new StringBuilder();
                index--;
            }
        }
        // 运算
        while (!operationStack.isEmpty()){
            int popChar = operationStack.pop();
            number2 = numberStack.pop();
            number1 = numberStack.pop();
            result = operationStack.calculation(number1,number2,popChar);
            numberStack.push(result);
        }
        System.out.println(numberStack.pop());

    }
}


class ArrayStack {
    // 栈大小
    private final int maxSize;
    // 栈数组
    int[] stack;
    // 栈顶指针，默认为-1，添加元素top++
    private int top;

    /**
     * 初始化栈
     */
    public ArrayStack(int maxSize) {
        this.maxSize = maxSize;
        stack = new int[this.maxSize];
        top = -1;
    }

    /**
     * 判断是否为空,top=-1,说明栈中没有元素
     *
     * @return top == -1
     */
    public boolean isEmpty() {
        return top == -1;
    }

    /**
     * 判断栈是否满了，
     *
     * @return
     */
    public boolean isFull() {
        return top == maxSize - 1;
    }

    /**
     * 添加元素
     *
     * @param i
     */
    public void push(int i) {
        if (isFull()) {
            System.out.println("栈满了，请不要再进来了");
            return;
        }
        top++;
        stack[top] = i;
    }

    /**
     * 从栈顶取出一个元素
     *
     * @return
     */
    public int pop() {
        if (isEmpty()) {
            System.out.println("栈是空的，请不要在进来取了");
            throw new EmptyStackException();
        }
        int retNum = stack[top];
        top--;
        return retNum;
    }

    /**
     * 遍历栈
     */
    public void traverse() {
        for (int thiChar : stack) {
            System.out.println(thiChar);
        }
    }

    /**
     * 判断符号优先级
     *
     * @param operation
     * @return
     */
    public int getPriority(int operation) {
        if (operation == '*' || operation == '/') {
            return 2;
        } else if (operation == '+' || operation == '-') {
            return 1;
        } else if (operation >= '0' && operation <= '9') {
            return 0;
        } else {
            return -1;
        }
    }

    /**
     * 比较符号栈和入栈符号元素的优先级
     *
     * @param operation
     * @return
     */
    public boolean comparePriority(int operation) {
        if (isEmpty()) {
            return true;
        } else {
            int priority1 = getPriority(operation);
            int priority2 = getPriority(stack[top]);
            return priority1 > priority2;
        }
    }

    /**
     * 判断输入的是否是一个运算符号
     *
     * @param operation
     * @return
     */
    public boolean isOperation(int operation) {
        return operation == '*' || operation == '/' || operation == '-' || operation == '+';
    }

    /**
     * 计算
     *
     * @param number1
     * @param number2
     * @param operation
     * @return
     */
    public int calculation(int number1, int number2, int operation) {
        switch (operation) {
            case '+':
                return number1 + number2;
            case '-':
                return number1 - number2;
            case '*':
                return number1 * number2;
            case '/':
                return number1 / number2;
            default:
                System.out.println(operation);
                throw new RuntimeException("符号读取错误！");
        }
    }

}