通过栈实现简单计算器

package com.baichuan.studyapp.test.shujujiegou;
import java.util.HashMap;
import java.util.Map;

/**
 * 使用两个栈的方式
 * 实现简单个位数加减乘除运算
 */
public class StackTest {

    public static void main(String[] args) {
        Calculator calculator = new Calculator();
        System.out.println(calculator.calculate("4+6*9+3+ 4*6 - 9"));//76
    }
}


//表达式计算
//如：3 + 4*6 - 9
//思路：两个栈来来实现，将表达式作为字符串切割后，遍历字符串
//遇到数字放到 数字栈里，遇到运算符放到 运算符栈

//对于运算符栈，如果要入栈的运算符比 当前栈顶的运算符 优先级高则直接入栈
//如果低或者相同，则取出当前栈顶 的运算符，同时取出数字栈的两个数进行计算，结果再放入数字栈

//接着未入栈的运算符 继续进行比较直至所有的运算符都入栈


/**
 * 自定义栈
 * @param <T>
 */
class CustomStack<T>{
    private Object[] elementArr = null;
    private int size;
    private int elementCount;

    public CustomStack(int size) {
        this.size = size;
        elementArr = new Object[size];
    }

    /**
     *
     * @param element 入栈元素
     * @return 是否入栈成功
     */
    public boolean push(T element){
        if (elementCount < size){
            elementArr[elementCount] = element;
            elementCount++;
            return true;
        }
        return false;
    }

    public T pop(){
        if (elementCount > 0){
            elementCount--;
            return (T)elementArr[elementCount];
        }
        return null;
    }

    public T get(){
        if (elementCount > 0){
            return (T)elementArr[elementCount-1];
        }
        return null;
    }
}


/**
 * 简单数字表达式计算器
 */
class Calculator{
    CustomStack<String> numberStack;
    CustomStack<String> operatorStack;

    //操作符 优先级表
    Map<String,Integer> priorityMap= new HashMap<>();

    public Calculator() {
        numberStack = new CustomStack<>(100);
        operatorStack = new CustomStack<>(100);
        priorityMap.put("+",0);
        priorityMap.put("-",0);
        priorityMap.put("*",1);
        priorityMap.put("/",1);
    }

    public long calculate(String expression){
        if (null== expression || expression.isEmpty())
            return -1;

        expression = expression.replaceAll("\\s*","");
        String[] chars = expression.split("");

        for (int i = 0; i < chars.length; i++) {
            String str = chars[i];

            if (str.matches("[0-9]+")){
                numberStack.push(str);

                if (i == chars.length - 1){
                    compute();

                    return Integer.parseInt(numberStack.pop());
                }


            } else {
                String operator = operatorStack.get();
                if (null != operator){
                    if (priorityMap.get(str) > priorityMap.get(operator)){
                        operatorStack.push(str);
                    } else {//优先级小于等于 栈顶部的操作符
                        

                        compute();
                        
                        //需要再次在表达式字符串中判断当前操作符的优先级
                        i--;

                    }


                } else {
                    operatorStack.push(str);
                }



            }
        }

        return -1;
    }

    /**
     * //取出操作符，和两个数字，进行运算，运算结果再放入 数字栈
     */
    private void compute(){
        //操作符出栈
        String popStr = operatorStack.pop();

        //数字出栈 两个
        String number1 = numberStack.pop();
        String number2 = numberStack.pop();

        //计算
        int number1Int = Integer.parseInt(number1);
        int number2Int = Integer.parseInt(number2);

        int result = 0;
        if (popStr.equals("+")){
            result = number2Int + number1Int;
        }
        if (popStr.equals("-")){
            result = number2Int - number1Int;
        }
        if (popStr.equals("*")){
            result = number2Int * number1Int;
        }
        if (popStr.equals("/")){
            result = number2Int / number1Int;
        }

        numberStack.push(String.valueOf(result));
    }

}