中置式の単純な電卓

中置式の単純な電卓

アイデア解析

1. 2つのスタックを定義し、スタック数であり、シンボルはさらにスタックである
2.優先レベル決意、減算、乗算、除算は、優先の優先度よりも大きい
3、ハンドル関数を定義する2つのオペランドおよびオペレータ計算結果オペレータ
インフィックス4.数がオペランドスタック上にある場合の動作である場合、オペレータは、比較的高い優先度であるオペレータの符号をスタックの最上部を考慮した場合、入力をスキャンスタックより優先、直接、スタックシンボルは、そうでない場合、シンボルは、オペランドスタックポップ操作が行われた2つのオペランドスタックと上部要素スタック取る、結果がオペレータスタック後、オペランドスタックに格納されます。
5等のスキャンが完了した文字列になるまでまで
最後6、連続ストリングkeepnumの数値を得るために設けられた継続性を、注意する改良されたデジタル、それはデジタル文字列を取得した後に空にすることに留意すべきですまた、アレイに注意を払うことに加え、国境を越えた問題。

コードの実装

Calculator.java

package stack;

import java.util.Scanner;

public class Calculator {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        String expression;//表达式
        System.out.println("请输入要计算的表达式:");
        expression=in.nextLine();
        in.close();
        //创建两个栈一个数字栈另外一个是符号栈
        ArrayStack numStack=new ArrayStack(10);
        ArrayStack operStack=new ArrayStack(10);
        
        //定义相关的变量
        int index=0;//用于扫描
        int num1=0;
        int num2=0;
        int oper=0;
        int res=0;
        char ch=' ';//每次扫描将char保存到ch
        String keepnum="";//用于拼接多位数的
        while(true) {
            //依次得到expression的每一个字符串
            ch=expression.substring(index, index+1).charAt(0);
            //判断
            if(operStack.isOper(ch)) {//如果是运算符
                if(!operStack.isEmpty()) {//如果字符栈不为空
                    if(operStack.priority(ch)<=operStack.priority(operStack.peek())) {
                        num1=numStack.pop();
                        num2=numStack.pop();
                        oper=operStack.pop();
                        res=numStack.cal(num1, num2, oper);
                        //把运算的结果放数栈
                        operStack.push(ch);
                        numStack.push(res);
                    }else {
                        operStack.push(ch);
                    }
                }else {//如果字符栈为空直接就入栈
                    operStack.push(ch);
                }
            }else {//如果是数字直接就入数栈
                //numStack.push(ch-48);//字符串转数字     
                //当处理多位数的时候，不可以发现一个数立即就入栈可能是多位数字
                //在处理数的时候，需要向expression后面，向这一位就继续扫描，如果是符号就入栈
                //定义一个字符串变量用于拼接
                keepnum+=ch;
                
                //如果已经是expression的最后一位就直接入栈不需要再进行判断
                if(index==expression.length()-1) {
                    numStack.push(Integer.parseInt(keepnum));
                }else {
                    if(operStack.isOper(expression.substring(index+1, index+2).charAt(0))) {
                        //如果后一位是操作符就入栈
                        numStack.push(Integer.parseInt(keepnum));
                        //重要要将累计字符串清空
                        keepnum="";
                    }
                }
                    
            }
            index++;
            if(index>=expression.length()) {
                break;
            }
                
        }
        //当表达式符号栈为空，则计算到最后的结果
        //数栈中只有一个结果
        while(true) {
            if(operStack.isEmpty()) {
                break;
            }
            num1=numStack.pop();
            num2=numStack.pop();
            oper=operStack.pop();
            res=operStack.cal(num1, num2, oper);
            numStack.push(res);
        }
        
        System.out.printf("表达式%s=%d\n",expression,numStack.pop());
        
        
    }
}

ArrayStack.java

package stack;

public class ArrayStack {
    private int maxSize;//最大值
    private int[] stack;//栈
    private int top=-1;//栈顶
    
    //构造器
    public ArrayStack(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;
        }else {
            top++;
            stack[top]=value;
        }
    }
    
    //出栈-pop
    public int pop() {
        if(isEmpty()) {
            throw new RuntimeException("栈已经空了~");
        }
        int value=stack[top];
        top--;
        return value;
    }
    
    //遍历栈
    
    public void list() {
        if(isEmpty()) {
            System.out.println("栈空，没有数据~");
        }
        for(int i=top;i>=0;i--) {
            System.out.printf("stack[%d]=%d\n",i,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:
            break;
        }
        return res;
    }
    
    public int peek() {
        return stack[top];
    }
    
}