java实现一个简单的数学表达式分析器（加减乘除和括号）

1.使用此分析器需要输入两个量：

  String str1=运算符号有前后有空格的数学表达式（如 1 + 2 *  ( 3+1)  - 5 #）,并在最后添加‘#’字符作为结束标志；

  String str2=无空格的分割的数学表达式（如 1+2*(3+1)-5#）,同样添加‘#’字符作为结束标志；

2.注：表达式必须严格正确“( )”是不允许存在单个的情况。源代码中有一定的检测机制，但现在还不确定是否能够检错所有情况；

          使用两种输入的原因是方便于检错和字符串的切割；

3.花了两天晚上写的（包括安卓app），虽然简陋。但是对于我来说还是太肝了。这个是为面试学校的一个学生组织的实验室，准备做的安卓上的计算器中的输入分析器（算是核心的代码了doge.jpg）；因为考虑到可能以后还可以改改，所以就单独写了个方法（算是低耦合吧doge.jpg）；

4.注：此代码暂时只能解析含加减乘除和括号的算式。主要核心算法思想参考《数据结构C语言版 吴伟民著》P53。其他的实现都是自己写的，把c转为java确实也遇到很多问题。

5.使用时使用的是EvaluateExpression这个类，创建是用构造方法EvaluateExpression(str2（不含空格）,str1（含空格）)，使用.doEvaluateExpression()方法实现计算（如果返回值为False则表示输入的表达式有误），使用.sum得到最后结果。

6.下面是步骤：

  实现一个栈：

public class strStack {
    private String[] myStack=new String[80];
    private int StackLength=0;
    private int StackPoint=0;
    public boolean isEmpty(){
        if(StackLength==0)
            return true;
        else
            return false;
    }
    public int getStacklength(){
        return StackLength;
    }
    public boolean push(String str){
        if(StackPoint==80)
            return false;
        else{
        myStack[StackPoint]=str;
        StackLength++;
        StackPoint++;
        return true;
        }
    }
    public String getTop(){
        if(StackPoint==0){
            return null;
        }else{
        return myStack[StackPoint-1];
        }
    }
    public String pop(){
        String popn=myStack[StackPoint-1];
        myStack[StackPoint-1]=null;
        StackLength--;
        StackPoint--;
        return popn;
    }
    public void clearStack(){
        if(!isEmpty()){
        for(int i=StackLength-1;i>=0;i--){
             myStack[i]=null;
        }
        StackLength=0;
        StackPoint=0;
       }
    }
    public void trevalstack(){
        for(int i=0;i<StackPoint;i++){
            System.out.print(" "+myStack[i]);
        }
    }
}

  实现字符串处理类：

public class cutStr {
    private String[] mystr;//切割后的表达式
    private String outstr;//不含空格的表达式
    private String outstrhasSpace;//含空格的表达式
    
    public cutStr(){ 
    }
    public cutStr(String outstr,String outstrhasSpace){ 
        this.outstr=outstr;
        this.outstrhasSpace=outstrhasSpace;//初始化，得到外来字符串
    }
    public String[] ReAddstr(){//切割字符串，将运算符号与数字分开
        mystr=outstrhasSpace.split("[ ]+");
        return mystr;
    }
    public boolean countsymple(){
        boolean temp=true;
        for(int i=0;i<outstr.length();i++){
            if(i!=outstr.length()-1){//判断是否有非法的连续输入
               if(outstr.charAt(i)=='+'||
                  outstr.charAt(i)=='-'||
                  outstr.charAt(i)=='*'||
                  outstr.charAt(i)=='/'||
                  outstr.charAt(i)=='.'){
                  if(outstr.charAt(i+1)=='+'||
                      outstr.charAt(i+1)=='-'||
                      outstr.charAt(i+1)=='*'||
                      outstr.charAt(i+1)=='/'||
                      outstr.charAt(i+1)=='.'){
                      temp=false;
                      break;
                   }
                }
            }else{//判断最后一个字符是否合法
                if(outstr.charAt(i)=='+'||
                   outstr.charAt(i)=='-'||
                   outstr.charAt(i)=='*'||
                   outstr.charAt(i)=='/'){
                   temp=false;
                   break; 
                }
            }
        }
        return temp;
    }
    public boolean khnumber(){
        int kl=0;
        int kr=0;
        for(int i=0;i<outstr.length();i++){
            if(outstr.charAt(i)=='(')
                kl++;
            if(outstr.charAt(i)==')')
                kr++;
        }
        if(kr==kl&&(kr+kl)%2==0)
            return true;
        else
            return false;
    }
    public String[] getMystr() {//返回切割后的字符串数组
        ReAddstr();
        return mystr;
    }
    
}

  实现运算符优先级比较处理类：

public class Precede {
    private char[][] mylist={{'>','>','<','<','<','>','>'},
                             {'>','>','<','<','<','>','>'},
                             {'>','>','>','>','<','>','>'},
                             {'>','>','>','>','<','>','>'},
                             {'<','<','<','<','<','=',0},
                             {'>','>','>','>',0,'>','>'},
                             {'<','<','<','<','<',0,'='}};
    public char doPrecede(char c1,char c2){//查询两者关系
        int c1n,c2n;
        c1n=exchange(c1);
        c2n=exchange(c2);
        return mylist[c1n][c2n];
    }
    public int exchange(char mychar){//将符号转换为自定义数字，用于定位表中位置
        int temp=-1;
        switch(mychar){
            case '+': temp=0; break;
            case '-': temp=1; break;
            case '*': temp=2; break;
            case '/': temp=3; break;
            case '(': temp=4; break;
            case ')': temp=5; break;
            case '#': temp=6; break;
        }
        return temp;
    }
}

  实现运算的操作类：

public class Operate {
    private double a;
    private double b;
    private char threta;
    public Operate(){
        
    }
     public Operate(double a,char threta,double b){
        this.a=a;
        this.b=b;
        this.threta=threta;
    }
    public double doOperaate(){
        double temp=0;
        switch(threta){
            case '+': temp=a+b;break;
            case '-': temp=a-b;break;
            case '*': temp=a*b;break;
            case '/': temp=a/b;break;
        }
        return temp;
    }
}

  实现运行运算的类：

public class EvaluateExpression {
    public String sum;//储存计算的最终结果
    public  boolean jugment=true;//作为表达式是否合法的标志
    String outstr,outstrhasSpace;
    public  EvaluateExpression(String outstr,String outstrhasSpace){
        this.outstr=outstr;
        this.outstrhasSpace=outstrhasSpace;
    }
    public boolean isOP(String x){//判断是否为运算符号的方法
        if(x.charAt(0)=='+'||x.charAt(0)=='-'||x.charAt(0)=='*'||x.charAt(0)=='/'||x.charAt(0)=='('||x.charAt(0)==')'||x.charAt(0)=='#')
            return true;
        else
            return false;
    }
    public boolean doEvaluateExpression(){//求解过程的方法，如果判断表达式错误那么直接结束
        Precede pre=new Precede();
        strStack OPTR=new strStack();
        OPTR.push("#");
        strStack OPND=new strStack();
        cutStr cS=new cutStr(outstr,outstrhasSpace);
        jugment=cS.countsymple();
        String[] mystr=cS.getMystr();
        jugment=cS.khnumber();
        for(int i=0;jugment&&((mystr[i].charAt(0)!='#')||(OPTR.getTop().charAt(0)!='#'));){
            if(!isOP(mystr[i])){
                  OPND.push(mystr[i]);
                  i++;
            }
            else{
                switch(pre.doPrecede(OPTR.getTop().charAt(0),mystr[i].charAt(0))){
                    case '<':
                                OPTR.push(mystr[i]);
                                i++;
                             
                             break;
                    case '=':
                                OPTR.pop();
                                i++;        
                             break;
                    case '>':String thretax=OPTR.pop();
                             char threta=thretax.charAt(0);
                             String b=OPND.pop();
                             String a=OPND.pop();
                             double bb=0;
                             double aa=0;
                             try{
                                 bb=Double.parseDouble(b);
                                 aa=Double.parseDouble(a);
                             }catch(NumberFormatException e){
                                 jugment=false;
                             }
                             Operate oper=new Operate(aa,threta,bb);//创建一个操作对象，并初始化
                             String numberx=String.valueOf(oper.doOperaate());
                             OPND.push(numberx);
                             break;
                    case '0':jugment=false;break;   
                }
            }
            /*System.out.print(i);
            System.out.print("   ");
            OPND.trevalstack();
            System.out.print("   ");
            OPTR.trevalstack();
            System.out.println("   ");*/
        }
        sum=OPND.getTop();
        return jugment;
    }
}