使用栈数据结构实现简易计算器算法

首先看一下设计思路：

具体代码实现：

package com.lhb.test;

import java.util.Stack;

/**
 * @Program: netty-chat 数字
 * @Description:
 * @Author: LHB
 * @Version: v0.0.1
 * @Time: 2021-11-01 15:02
 **/
public class CalculateStack {
    // 操作数栈
    private Stack<Integer> numberStack = new Stack<>();
    // 符号栈
    private Stack<Character> operatorStack = new Stack<>();
    public Integer calculate(String des) {
        for (int i = 0; i < des.length(); i++) {
            // 如果读取出来的是数字，直接将数字加入到操作数栈，否则加入的符号栈中
            if (Character.getType(des.charAt(i)) == 9) {
                // 读取出来的是ASCII码，需要减去48才是真正是数字
                numberStack.push(Integer.valueOf(des.charAt(i)-48));
            } else {
                // 如果符号栈为空，则直接加入到符号栈中
                if (operatorStack.isEmpty()) {
                    operatorStack.push(des.charAt(i));
                } else {
                    // 如果符号栈不为空，则比较符号栈栈顶符号和截取出来的符号的优先级，如果小于栈顶符号优先级，则取出栈顶符号和操作数栈中的两个数字做运算，
                    // 并将最后运算结果重新加入到操作数栈中，同时将此刻解析到的符号加入到符号栈中
                    if (priority(des.charAt(i)) <= priority(operatorStack.peek())) {
                        Integer sec = numberStack.pop();
                        Integer fir = numberStack.pop();
                        Character operator = operatorStack.pop();
                        int result = this.cal(fir, sec, operator);
                        numberStack.push(result);
                        operatorStack.push(des.charAt(i));
                    } else {
                        operatorStack.push(des.charAt(i));
                    }
                }
            }
        }

        // 处理符号栈中剩余的还没有做运算的符号
        while(true) {
            if (operatorStack.isEmpty()) {
                break;
            }
            Integer sec = numberStack.pop();
            Integer fir = numberStack.pop();
            Character operator = operatorStack.pop();
            int result = cal(fir, sec, operator);
            numberStack.push(result);
        }
        // 最后留在操作数栈中的数字，就是最后表达式的运算结果
        return numberStack.pop();
    }

    /**
     * 获取操作数优先级
     * @param operator 操作数
     * @return
     */
    public int priority(char operator) {
        if (operator == '*' || operator == '/') {
            return 1;
        } else if (operator == '+' || operator == '-') {
            return 0;
        } else {
            return -1;
        }
    }

    /**
     * 做计算操作
     * @param a
     * @param b
     * @param operator
     * @return
     */
    public int cal(int a, int b, int operator) {
        int result = 0;
        switch (operator){
            case '+':
                result = a + b;
                break;
            case '-':
                result = a - b;
                break;
            case '*':
                result = a * b;
                break;
            case '/':
                result = a / b;
                break;
            default:
                break;
        }
        return result;
    }


    public static void main(String[] args) {
        Integer calculate = new CalculateStack().calculate("8+4*3-6/2+1");
        System.out.println("8+4*3-6/2+1 = " + calculate);
    }
}