JAVA栈实现简单的计算器

本次使用栈来模拟计算器的实现
例如 15 + 2 × 3 - 3
我们需要两个栈来辅助实现

• 符号栈（用来存储符号）
• 数字栈（用来存储运算的数字和结果）

实现思路：

• 5+2*3-3
  1.通过一个index值(索引)，来遍历我们的表达式
  2.如果我们发现是一个数字。就直接入数栈
  3.如果发现扫描到的是一个符号,就分如下情况
  3.1 如果发现当前的符号栈为空，就直接入符号栈。
  3.2 如果符号栈有操作符，就进行比较。

  • 1）如果当前的操作符的优先级小于或者等于栈中的操作符，这时就需要从数栈中pop出两个数，然后再从符号栈中pop出一个符号，进行运算。将得到的结果，入数栈。然后将当前的操作符入符号栈。
  • 2）如果当前的操作符的优先级大于栈中的操作符，就直接入符号栈

4.当表达式扫描完毕，就顺序的从数栈和符号栈中pop出相应的数和符号，并运行
5.最后在数栈只有一个数字，就是表达式的结果。

首先，依次添加，知道遇到➖号时停止，此时满足➖号的优先级小于✖的优先级，需要从数字栈中pop出，两个数和符号栈pop出一个符号进行运算。

运算完成之后，将得到的结果入数栈，然后将此时遍历的表达式的符号入符号栈。

直到，扫描完表达式为止。依次将栈中的数字pop然后运算。



最后数字栈中只留下了一个元素，即为得到的表达式的结果。

下面代码奉上：

/**
 * 栈实现完成计算一个表达式的结果
 * 7*2*2-5+1-5+3-4
 * 5+2*3-3
 * 思路： 1.通过一个index值(索引)，来遍历我们的表达式
 * 2.如果我们发现是一个数字。就直接如数栈
 * 3.如果发现扫描到的是一个符号,就分如下情况
 * 3.1 如果发现当前的符号栈为空，就直接入栈。
 * 3.2 如果符号栈有操作符，就进行比较。
 * 1）如果当前的操作符的优先级小于或者等于栈中的操作符，这时就需要从数栈中pop出两个数
 * 然后再从符号栈中pop出一个符号，进行运算。将得到的结果，入数栈。然后将当前的操作符入符号栈。
 * 2）如果当前的操作符的优先级大于栈中的操作符，就直接入符号栈
 * 4.当表达式扫描完毕，就顺序的从数栈和符号栈中pop出相应的数和符号，并运行
 * 5.最后在数栈只有一个数字，就是表达式的结果。
 */
public class StackImplCalculator {
    public static void main(String[] args) {
        String mathTest = "100-20-3*20";
        ArrayStack2 numberStack = new ArrayStack2(10);
        ArrayStack2 opStack = new ArrayStack2(10);
        String keepNum=""; //此字符串用于保存多位数字的情况
        for (int i = 0; i < mathTest.length(); i++) {
            if (!numberStack.isOperator(mathTest.charAt(i))) { //如果是数字
                keepNum+=mathTest.charAt(i);
                if(i==mathTest.length()-1){//如果时字符串最后一个数字，则添加存储的数字，结束循环
                    numberStack.push(Integer.parseInt(keepNum));
                }else {
                    if(numberStack.isOperator(mathTest.substring(i+1,i+2).charAt(0))){//如果下一位是运算符
                        //numberStack.push(Integer.parseInt(String.valueOf(mathTest.charAt(i))));
                        numberStack.push(Integer.parseInt(keepNum));
                        keepNum="";
                    }
                }
            } else if (mathTest.charAt(i) == '+' || mathTest.charAt(i) == '-' || mathTest.charAt(i) == '*' || mathTest.charAt(i) == '/') {
                if (opStack.isEmpty()) {
                    opStack.push(mathTest.charAt(i));
                } else if (opStack.getPriority(mathTest.charAt(i)) > opStack.getPriority(opStack.getHead())) {//获取两个字符的优先级
                    //如果要加入的运算符的优先级大于了栈顶的元素的优先级，则直接入栈
                    opStack.push(mathTest.charAt(i));
                } else {
                    //如果要加入的运算符的优先级小于等于栈顶元素的优先级，则从数字栈中取出两个数，从字符栈中取出栈顶的运算符进行运算
                    //运算完成后，将运算成功的结果入数字栈，将待加入的运算符入符号栈
                    int num1 = numberStack.pop();
                    int num2 = numberStack.pop();
                    int op = opStack.pop();
                    int result = numberStack.DoTheOperation(num2, num1, op);
                    numberStack.push(result);
                    opStack.push(mathTest.charAt(i));
                }
            }
        }

        //遍历完字符串之后，需要将存留在栈中的元素进行运算，当数字栈中只有一个元素时，运算结束
        while (numberStack.getTop() != 0) {
            int num1 = numberStack.pop();
            int num2 = numberStack.pop();
            int op = opStack.pop();
            int result = numberStack.DoTheOperation(num2, num1, op);
            numberStack.push(result);
        }

        System.out.println("最后运算的结果为：" + numberStack.getHead());

    }
}


//定义一个 ArrayStack 表示栈
class ArrayStack2 {
    private int maxSize; //栈的大小
    private int[] stack; //数组，数组模拟栈,数据就放在该数组。
    private int top = -1; //top表示栈顶，初始化为-1

    public int getTop() {
        return top;
    }

    //构造器
    public ArrayStack2(int maxSize) {
        this.maxSize = maxSize;
        stack = new int[this.maxSize];
    }

    //栈满
    public boolean isFull() {
        return top == maxSize - 1;
    }

    //栈空
    public boolean isEmpty() {
        return top == -1;
    }

    //入栈(push)
    public void push(int value) {
        //先判断栈是否满
        if (isFull()) {
            System.out.println("栈满");
            return;
        }
        top++;
        stack[top] = value;
    }

    //出栈
    public int pop() {
        //先判断栈是否为空
        if (isEmpty()) {
            throw new RuntimeException("栈空,没有数据");
        }
        int p = stack[top]; //记录下来原来的栈顶元素
        top--;
        return p;
    }


    //展示栈
    public void show() {
        //先判断栈是否为空
        if (isEmpty()) {
            throw new RuntimeException("栈空,没有数据");
        }
        for (int i = 0; i <= top; i++) {
            System.out.printf("%d ", stack[i]);
        }
        System.out.println();
    }

    //获取字符的优先级
    public int getPriority(int op) {
        if (op == '+' || op == '-') {
            return 0;
        } else if (op == '*' || op == '/') {
            return 1;
        } else {//其他情况返回错误
            return -1;
        }
    }

    //返回栈顶的元素
    public int getHead() {
        return stack[top];
    }

    public boolean isOperator(int op) {
        return op == '*' || op == '/' || op == '+' || op == '-';
    }

    public int DoTheOperation(int n1, int n2, int op) {
        int result = 0;
        switch (op) {
            case '*':
                result = n1 * n2;
                break;
            case '/':
                result = n1 / n2;
                break;
            case '+':
                result = n1 + n2;
                break;
            case '-':
                result = n1 - n2;
                break;
        }
        return result;
    }
}

下一篇文章，我们用栈来实现后缀表达式的计算器。