使用栈完成一个简易的计算器（加减乘除功能）

1，基本思路

        1，创建一个计算工具类

                1，加减乘除方法

                2，判断符优先级

                3，判断是否是运算符号

        2，实现计算器

                1，创建一个符号栈用来存储符号

                2，创建一个数字栈用来存储数字

                3，进行运算

                4，思路

                        

                5，多位数的处理 

        当处理多位数时，不能发现是一个数就立即入栈，因为他可能是多位数。 在处理数，需要向 expression 的表达式的 index 后再看一位,如果是数就进行扫描，如果是符号 才入栈。 因此我们需要定义一个变量 字符串，用于拼接处理多位数

2，代码实现

        1，计算工具类

package 数据结构.栈.模拟计算器;
//计算工具类
public class JSUtils {
    //1,判断字符是否是运算符
    public static boolean isOper(char val){
        return val=='+'||val=='-'||val=='*'||val=='/';
    }

    //2，判断运算符的优先级,数字越大，则优先级就越高.
    public static int priority(char oper){
        if(oper=='+'||oper=='-'){
            return 0;
        }
        else if(oper=='*'||oper=='/'){
            return 1;
        }
        return -1;
    }

    //3,计算方法
    public static int cal(int num1,int num2,char oper){
        switch (oper){
            case '+':
                return num1+num2;
            case '-':
                return num2-num1;
            case '*':
                return num1*num2;
            case '/':
                return num2/num1;
            default:
                return 0;
        }
    }
}

        2，简易计算器 

package 数据结构.栈.模拟计算器;

import java.util.Scanner;
import java.util.Stack;

public class Calculator {
    public static void main(String[] args) {
        while (true){
            Scanner in =new Scanner(System.in);
            //1,输入计算表达式
            System.out.println("请输入计算式：");
            String expression=in.next();
            //2,创建数字栈
            Stack <Integer>numStack=new Stack();
            //3,创建符号栈
            Stack <Character> operStack=new Stack();
            char c=' ';
            int res=0;
            String keepNum="";//用于拼接数字
            int index=0;//用于扫描
            //入栈
            while(index<expression.length()){
                c=expression.substring(index,index+1).charAt(0);
                //如果c是符号，压入符号栈
                if(JSUtils.isOper(c)){
                    //判断符号栈是否为空，空的话直接压入
                    if(operStack.isEmpty()){
                        operStack.push(c);
                    }
                    else {
                        //符号栈不为空，判断栈中符号与当前符号的优先级
                        if(JSUtils.priority(c)>JSUtils.priority(operStack.peek())){
                            //若当前符号优先级高，直接入栈
                            operStack.push(c);
                        }
                        else {
                            //若栈中符号优先级高，将其取出运算，将新的结果入数栈，当前符号入符号栈
                            res = JSUtils.cal(numStack.pop(), numStack.pop(), operStack.pop());
                            numStack.push(res);
                            operStack.push(c);
                        }
                    }
                }
                //若果不是符号，说明是数字,入数字栈
                else {
                    //判断是否是多位数字
                    //如果c是表达式最后一位，直接入栈
                    keepNum+=c;
                    if(index==expression.length()-1){
                        numStack.push(Integer.parseInt(keepNum));
                    }
                    else {
                        //判断下一个字符是否是数字
                        if(JSUtils.isOper(expression.substring(index+1,index+2).charAt(0))){
                            //不是数字，直接入栈
                            numStack.push(Integer.parseInt(keepNum));
                            keepNum="";
                        }
                    }
                }
                index++;
            }
            //入栈完成,将两个栈中数据取出运算
            //当符号栈为空时，计算完成
            while (!operStack.isEmpty()){
                //计算
                res=JSUtils.cal(numStack.pop(), numStack.pop(), operStack.pop());
                //将res入数字栈
                numStack.push(res);
            }
            //此时符号栈为空，数字栈中剩下的最后一个数字，就是运算结果
            System.out.println(numStack.pop());
        }
    }
}