java栈实现计算器

使用完成一个表达式的计算

实现思路：

先创建两个栈，一个数字栈（numstack）,一个字符栈（operstack）

1.通过一个index值（索引），来遍历表达式，

2.如果我们发现的是一个数字就直接放入数字栈中。

3.如果发现的是一个运算符：

3.1.如果栈中为空就直接入栈。

3.2.如果符号栈中有运算符，就进行比较，

                 如果当前的运算符优先级小于或等于栈中的运算符，就需要从数字栈中pop两个数字，再从字符栈中pop出一个字符，进行运算，将得到的结果，入数栈，然后将当前的操作符入符号栈，

                如果当前的操作符的优先级大于栈中的操作符则直接入栈。

4.当表达式扫描完毕，就顺序的从数栈和符号栈中pop出相应的数和符号，并进行运算。

5.最后当数字中只剩下一个数字时就是表达式的结果

图例：

 创建一个栈

class ArrayStack2 {
    private int maxsize;//表示栈的大小
    private int[] stack;//数组模拟栈，数据存储在数组中
    private int top;//代表栈顶,初始值-1

    //构造器
    public ArrayStack2(int maxsize) {
        this.maxsize = maxsize;
        this.stack = new int[maxsize];
        top = -1;
    }

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

    //判断栈空
    public boolean isEmpth() {
        return top == -1;
    }

    /**
     * 增加返回栈顶数据的方法，只是查看并不是出栈
     */
    public int peek() {
        return stack[top];
    }

    /**
     * 创建入栈的方法
     */
    public void Push(int value) {
        //先判断栈是否为满
        if (isFull()) {
            //为满则不添加数据
            System.out.println("栈满");
            return;
        }
        top++;
        stack[top] = value;
    }

    /**
     * 创建出栈的方法
     */
    public int Pop() {
        //先判断栈是否为空
        if (isEmpth()) {
            //抛出异常
            throw new RuntimeException("栈空");
        }
        int value = stack[top];
        top--;
        return value;
    }

    /**
     * 创建遍历栈的方法
     */
    public void list() {
        //判断是否为空
        if (isEmpth()) {
            System.out.println("栈空");
            return;
        }
        //从栈顶开始遍历
        for (int i = top; i >= 0; i--) {
            System.out.println("stack  key:" + i + "valve" + stack[i]);
        }
    }

    /**
     * 返回运算符的优先级、优先级由我们自己来定义，优先级用数字来表示
     * 数字越大优先级越高
     */
    public int priority(int oper) {
        if (oper == '*' || oper == '/') {
            return 1;
        } else if (oper == '+' || oper == '-') {
            return 0;
        } else {
            return -1;
        }
    }

    /**
     * 判断是不是一个运算符
     */
    public boolean isOper(char val) {
        return val == '*' || val == '/' || val == '-' || val == '+';
    }

    /**
     * 计算方法
     */
    public int cal(int num1, int num2, int oper) {
        int res = 0;//存储值
        switch (oper) {
            case '+':
                res = num1 + num2;
                break;
            case '-':
                res = num2 - num1;//注意顺序
                break;
            case '*':
                res = num1 * num2;
                break;
            case '/':
                res = num2 / num1;
                break;
            default:
                System.out.println("错误");
                break;
        }
        return res;
    }
}

代码实现

 //定义一个表达式
        String expression = "30+200*6-20000";
        //创建两个栈，数字栈和字符栈
        ArrayStack2 NumStack = new ArrayStack2(10);
        ArrayStack2 OperStack = new ArrayStack2(10);
        //定义需要的变量
        int index = 0;//用于扫描，逐个将数字和字符取出
        int num1 = 0;//数字一用于计算
        int num2 = 0;//数字二用于计算
        int oper = 0;//字符用于计算
        int res = 0;//运算后的结果
        char ch = ' ';//将每次扫描得到的char保存在ch中
        String keepNum = "";//用于拼接多位数
        //用while扫描expression这个表达式的每一个字符
        while (true) {
            //依次得到expression的每一个字符
            ch = expression.substring(index, index + 1).charAt(0);
            //判断ch是什么
            if (OperStack.isOper(ch)) {//如果是运算符
                //判断当前符号栈是不是为空
                if (!OperStack.isEmpth()) {
                    // 如果符号栈中有运算符，就进行比较，
                    //
                    //如果当前的运算符优先级小于或等于栈中的运算符，就需要从数字栈中pop两个数字，
                    // 再从字符栈中pop出一个字符，进行运算，将得到的结果，入数栈，然后将当前的操作符入符号栈，
                    if (OperStack.priority(ch) <= OperStack.priority(OperStack.peek())) {
                        num1 = NumStack.Pop();//取出数字栈的第一个栈放入num1
                        num2 = NumStack.Pop();//取出数字栈的第二个栈放入num2
                        oper = OperStack.Pop();//取出字符栈的第一个栈放入oper
                        res = NumStack.cal(num1, num2, oper);
                        //把计算的结果放入数字栈中
                        NumStack.Push(res);
                        //将当前的运算符放入符号栈
                        OperStack.Push(ch);
                    } else {
                        //如果当前的操作符的优先级大于栈中的操作符则直接入栈。
                        OperStack.Push(ch);
                    }
                } else {
                    //如果栈中为空就直接入栈。
                    OperStack.Push(ch);
                }
            } else {//如果是数字，直接入数栈
                //特别注意
                //1.当处理多位数时，不能只取一位就入栈
                //2.在处理数，需要再向expression的表达式后一位查看，如果是数字就还要继续扫描，如果为字符才入栈
                //3.因此我们需要定义一个变量，用于拼接

                //处理多位数
                keepNum += ch;
                //如果ch已经是expression表达式的最后一位则直接入栈
                if (index == expression.length() - 1) {
                    NumStack.Push(Integer.parseInt(keepNum));
                } else {
                    //判断下一个字符是不是数字，如果是数字就暂时不入栈，如果下一位是字符则入栈；
                    //注意是看后一位，而不是index后移一位
                    if (OperStack.isOper(expression.substring(index + 1, index + 2).charAt(0))) {
                        //如果后一位是运算符则入栈 ,将字符串keepNum转为数字在入栈
                        NumStack.Push(Integer.parseInt(keepNum));
                        //!注意keepNum在这里必须清空!
                        keepNum = "";
                    }
                }

            }
            //index+1并判断是否扫描到表达式的最后
            index++;
            if (index >= expression.length()) {
                break;
            }
        }
        //当表达式扫描完毕，就顺序的从数栈和符号栈中pop出相应的数和符号，并进行运算。
        //
        //最后当数字中只剩下一个数字时就是表达式的结果
        while (true) {
            //如果符号栈为空，则计算到最后的结果，数字栈也就只剩一个结果了
            if (OperStack.isEmpth()) {
                break;
            }
            //优先级高的运算符已经在上一步中提前算完了，剩下的只需要从前往后算就可以
            num1 = NumStack.Pop();
            num2 = NumStack.Pop();
            oper = OperStack.Pop();
            res = NumStack.cal(num1, num2, oper);
            NumStack.Push(res);
        }
        System.out.println(expression + " = " + NumStack.Pop());
    }

效果展示

30+200*6-20000 = -18770