【Java】利用栈实现简单的计算器功能

• 源码分为栈类的定义和主函数。

public class ArrayStack {
    //栈的大小
    private int maxStack;
    //用数组模拟栈
    private int[] stack;
    //表示栈顶，默认情况无数据时，默认值-1
    private int top = -1;

    public ArrayStack(int maxStack) {
        this.maxStack = maxStack;
        stack = new int[maxStack];
    }

    /*
    1。压栈
    2，弹栈
    3.判断是否空栈
    4.判断是否满栈
     */

    //判断是否满栈
    public boolean isFull() {
        return this.top == this.maxStack - 1;

    }

    //判断是否是空栈
    public boolean isEmpty() {
        return this.top == -1;
    }

    /*
    压栈
     */
    public void push(int val) {
        //判断是否栈满
        if (isFull()) {
            throw new RuntimeException("此栈已满。");
        }
        top++;
        stack[top] = val;

    }

    /*
    弹栈
     */
    public int pop() {
        //判断是否为空栈
        if (isEmpty()) {
            throw new RuntimeException("空栈，没有数据。");
        }
        int value = stack[top];
        top--;
        return value;
    }

    /*
    查看栈中所有元素
     */
    public void list() {
        //判断是否空栈
        if (isEmpty()) {
            throw new RuntimeException("空战，没有数据");
        }


        for (int i = 0; i < stack.length; i++) {
            System.out.printf("stack[%d]=%d", i, stack[i]);
        }
    }

    /*
    栈中元素存在的个数
     */
    public int length() {
        return this.top + 1;
    }

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

    /*
     * 获取栈的容量
     * */
    public int stackLength() {
        return this.stack.length;
    }

    /*
     * 获取栈顶数据
     * */
    public int peek() {
        return this.stack[top];
    }

    /*判断运算符优先级
     */
    public int priority(int oper) {
        if (oper == '*' || oper == '/') {
            return 1;
        } else if (oper == '+' || oper == '-') {
            return 0;
        } else {
            return -1;
        }
    }

    //计算两个数运算的结果
    public int calculate(int num1,int num2,int oper){
        //计算结果
        int refult=0;
        switch (oper){
            case '+':
                refult=num2+num1;
                break;
            case '-':
                refult=num2-num1;
                break;
            case '*':
                refult=num1*num2;
                break;
            case '/':
                refult=num2/num1;
                break;
            default:
                break;

        }
        return refult;
    }
    public int calculate2(int num2,int num1,int oper){
        //计算结果
        int refult=0;
        switch (oper){
            case '+':
                refult=num2+num1;
                break;
            case '-':
                refult=num2-num1;
                break;
            case '*':
                refult=num1*num2;
                break;
            case '/':
                refult=num2/num1;
                break;
            default:
                break;

        }
        return refult;
    }
}

public class Counter {
    public static void main(String[] args) {
        String str= "";
        Scanner scanner=new Scanner(System.in);
        if(scanner.hasNext()){
            str=str+scanner.next();
        }
        /*
         * 1.需要遍历字符串，获取每一个字符
         * 2.判断当前字符是一个运算符还是一个数字
         * 3.把数字存放在数字栈中，把运算符存放在运算符栈中
         * 4.运算符栈：如果是空栈，则直接运算符入栈，如果运算符栈已有运算符，就需要对比优先级，
         * 新进来的运算符如果小于等于原栈中的运算符，
         * 那就需要把原运算符弹出，数字栈中的数字进行弹栈，进行运算，运算后的结果重新放入数字栈，新运算符入栈。
         * 如果新运算符优先级大于原符号栈中运算符，那么的符号直接入栈。
         */
        ArrayStack numStack=new ArrayStack(10);
        ArrayStack symbolStack=new ArrayStack(10);
        //获取字符串长度

        int temp1=0;
        int temp2=0;
        int symbolChar=0;
        int refult=0;
        int length=str.length();
        /*
        * 如果数字是多位数，需要进行字符串拼接
        * */
        //StringBuilder values=new StringBuilder();

        String values="";


        //压栈过程
        for (int i=0;i<length;i++){
            char c=str.charAt(i);
            //是否是一个运算符
            if (symbolStack.isOper(c)){
                //判断是否是一个空栈
                if(!symbolStack.isEmpty()){
                    //比较运算符的优先级
                    if(symbolStack.priority(c)<=symbolStack.priority(symbolStack.peek())){
                        /*
                        1.获取栈顶的符号
                        2.去数字栈中获取两个数字
                        * */
                        temp1=numStack.pop();
                        temp2=numStack.pop();
                        symbolChar=symbolStack.pop();
                        refult=numStack.calculate(temp1,temp2,symbolChar);

                        //将运算结果再次放入数字栈
                        numStack.push(refult);
                        //将当前符号压入符号栈中
                        symbolStack.push(c);

                    }else {
                        symbolStack.push(c);
                    }

                }else {
                    //如果是空符号栈，直接压栈
                    symbolStack.push(c);
                }

            }else{
                //如果是多位数
                //values.append(c);
                //String value=values.toString();
                //一般最后一个字符是数字，这里不做判断，默认最后一个字符是数字
                values+=c;
                if(i==length-1){
                    numStack.push(Integer.parseInt(values));
                }else{
                    char data=str.substring(i+1,i+2).charAt(0);
                    if (symbolStack.isOper(data)){
                        numStack.push(Integer.parseInt(values));
                        values="";
                    }
                }
            }
        }

        //弹栈过程
        while(true){
            if(symbolStack.isEmpty()){
                break;
            }
            temp1=numStack.pop();
            temp2=numStack.pop();
            symbolChar=symbolStack.pop();
            refult=numStack.calculate(temp1,temp2,symbolChar);
            numStack.push(refult);
        }
        int res=numStack.pop();
        System.out.println("结果是："+res);
    }
}