只能实现个位数的运算

    1. package com.atguigu.stack;
    3. import java.util.Scanner;
    5. /**
    6.  * 用栈实现计算器,不能处理多位数运算
    7.  * @author Dxkstart
    8.  * @create 2021-10-08-17:45
    9.  */
    10. public class Calculator {
    11.     public static void main(String[] args) {
    12.         Scanner scanner = new Scanner(System.in);
    13.         System.out.println("请输入计算式：");
    14.         String expression = scanner.next();
    16.         //创建两个栈，数栈、符号栈
    17.         ArrayStack2 numStack = new ArrayStack2(10);
    18.         ArrayStack2 operStack = new ArrayStack2(10);
    19.         //定义需要的相关变量
    20.         int index = 0;//用于扫描
    21.         int num1 = 0;
    22.         int num2 = 0;
    23.         char oper = ' ';
    24.         int res = 0;//存放结果
    25.         char ch  = ' ';//将每次扫描得到的char保存到ch
    27.         //开始while循环的扫描expression
    28.         while (true){
    29.             //依次得到expression的每一个字符
    30.             ch = expression.substring(index,index+1).charAt(0);
    31.             //判断ch是什么，然后做相应的处理
    32.             if (operStack.isOper(ch)){//如果是运算符
    33.                 //判断当前的符号栈是否为空
    34.                 if (!operStack.isEmpty()){
    35.                     //如果符号栈有操作符，就进行比较，如果当前的操作符的优先级小于或者等于栈中的操作符，就需要从数栈中pop出两个数，
    36.                     //再从符号栈中pop出一个符号，进行运算，将的到的结果，入数栈，然后将当前的操作符入符号栈
    37.                     if (operStack.priority(ch) <= operStack.priority(operStack.peek())){//当前的操作符的优先级小于或者等于栈中的操作符
    38.                         num1 = numStack.pop();
    39.                         num2 = numStack.pop();
    40.                         oper = (char) operStack.pop();
    41.                         //计算
    42.                         res = numStack.cal(num1, num2, oper);
    43.                         numStack.push(res);
    44.                         //将当前的操作符入符号栈
    45.                         operStack.push(ch);
    46.                     } else { //当前的操作符的优先级大于栈中的操作符，直接入栈
    47.                         operStack.push(ch);
    48.                     }
    49.                 }else {
    50.                     //如果为空直接入栈
    51.                     operStack.push(ch);
    52.                 }
    54.             }else {//不是运算符时
    55.                 numStack.push(ch - 48);//注意这里的ch是char型，不是int型, '1' = 48
    56.             }
    58.             //判断结束
    59.             index++;
    60.             if (index >= expression.length()){
    61.                 break;
    62.             }
    63.         }
    64.         //当表达式扫描完毕，就顺序的从数栈和符号栈中pop出相应数和符号，并运算
    65.         while (true){
    66.             //如果符号栈为空，则计算到最后的结果，数栈中只有一个数字【结果】
    67.             if (operStack.isEmpty()){
    68.                 break;
    69.             }else {
    70.                 num1 = numStack.pop();
    71.                 num2 = numStack.pop();
    72.                 oper = (char) operStack.pop();
    73.                 //计算
    74.                 res = numStack.cal(num1, num2, oper);
    75.                 numStack.push(res);
    76.             }
    77.         }
    78.         System.out.printf("表达式%s = %d",expression,numStack.pop());//输出最终结果
    80.     }
    81. }
    85. //定义一个ArrayStack表示栈
    86. class ArrayStack2 {
    87.     private int maxSize;//栈的大小
    88.     private int[] stack;//数组，数组模拟栈，数据就放在该数组中
    89.     private int top = -1;//top表示栈顶，初始化为-1
    91.     //构造器
    92.     //初始化栈
    93.     public ArrayStack2(int maxSize) {
    94.         this.maxSize = maxSize;
    95.         stack = new int[maxSize];
    96.     }
    98.     //可以返回当前栈顶的数据，而不是弹出
    99.     public int peek(){
    100.         return stack[top];
    101.     }
    104.     //栈满
    105.     public boolean isFull() {
    106.         return top == maxSize - 1;
    107.     }
    109.     //栈空
    110.     public boolean isEmpty() {
    111.         return top == -1;
    112.     }
    114.     //入栈 - push
    115.     public void push(int value) {
    116.         //先判断栈是否满
    117.         if (isFull()) {
    118.             System.out.println("栈满");
    119.             return;
    120.         }
    121.         top++;
    122.         stack[top] = value;
    123.     }
    125.     //出栈 - pop,将栈顶的数据返回
    126.     public int pop() {
    127.         //先判断是否为空
    128.         if (isEmpty()) {
    129.             //抛出异常
    130.             throw new RuntimeException("栈空");
    131.         }
    132.         int value = stack[top];
    133.         top--;
    134.         return value;
    135.     }
    137.     //显示栈的所有数据【遍历栈】
    138.     public void list() {
    139.         //先判断是否为空
    140.         if (isEmpty()) {
    141.             //抛出异常
    142.             throw new RuntimeException("栈空");
    143.         }
    144.         //需要从栈顶开始显示数据
    145.         for (int i = top; i >= 0; i--) {
    146.             System.out.printf("stack[%d] = %d \n", i, stack[i]);
    147.         }
    149.     }
    151.     //返回运算符的优先级，优先级是程序员来确定的，优先级使用数字表示
    152.     //数字越大，优先级就越高。
    153.     public int priority(int oper) {
    154.         if (oper == '*' || oper == '/'){
    155.             return 1;
    156.         }else if (oper == '+' || oper == '-'){
    157.             return 0;
    158.         }else {
    159.             return -1;//假定当前的表达式只有 + - * /
    160.         }
    161.     }
    163.     //判断是不是一个运算符
    164.     public boolean isOper(char val){
    165.         if (val == '+' || val == '-' || val == '*' || val == '/'){
    166.             return true;
    167.         }else {
    168.             return false;
    169.         }
    170.     }
    172.     //计算方法
    173.     public int cal(int num1,int num2,char oper){
    174.         int res = 0;//res用于存放计算的结果
    176.         switch (oper){
    177.             case '+':
    178.                 res = num1 + num2;
    179.                 break;
    180.             case '-':
    181.                 res = num2 - num1;//注意顺序
    182.                 break;
    183.             case '*':
    184.                 res = num1 * num2;
    185.                 break;
    186.             case '/':
    187.                 res = num2 / num1;//注意顺序
    188.                 break;
    189.         }
    190.         return res;
    191.     }
    192. }