算术表达式求解java实现

一.处理的对象

算术表达式(Arithmetical Expression)：一个任意给定的由+、-、*、/、(、)以及阿拉伯数字组成的字符串，把"0.123456789"还有负号作为操作数，把"(+-*/)"作为操作符。例如：(12.89+(-9))*2.65/(-3)。

二.处理的方法

1.定义两个栈，一个操作符(operator)栈，一个操作数(operand)栈。

2.判断表达式是否合法，合法进入3，否则进入4。

①字符合法性检验，每个字符必须是算术表达式中要求的字符；

②括号匹配检验，包括个数是否匹配，以及位置是否正确合法。

"("前不能有操作数，后不能有操作符；")"前不能有操作符，后不能有操作数。

③小数点合法性检验，其前其后都要有数字。

④操作符合法性检验，操作符两边要有操作数。

⑤区分"-"是操作数中的负号还是操作符中的减号。

3.解析表达式并运算。

①遇到操作符确定不是负号，从上一个操作符位置开始截取字符串，把结果转换成double型数据，放入操作数栈；

②遇到操作符。

如果是"+-",从操作数栈中取出两个操作数，从操作符栈中取出一个操作符做运算，把运算的结果放入操作数栈中，同时把当前遇到的操作符放入操作符栈中。

如果是"*/",判断操作符中的最后一个操作符,如果是"*/",从操作数栈中取出两个操作数，从操作符栈中取出一个操作符做运算，把运算的结果放入操作数栈中，同时把当前遇到的操作符放入操作符栈中；如果是"+-",把当前操作符放入操作符栈中。

③对于一个含有括号的算术表达式，只需从最内层括号部分开始次做②的运算，直到操作符栈空结束。

4.得到结果信息，处理完毕。

三.JAVA实现

package ttwork.expression;

import java.util.Stack;

public class ArithExpression {
    private String expression;     //定义算术表达式的域
    private String errorMessage;   //定义错误信息域
    private String result = "0";   //定义表达式的结果

    public ArithExpression() {
        expression = null;
        errorMessage = null;
    }
    public ArithExpression(String str) {
        expression = str;
    }

    public boolean isDigit(char ch) {         //判断表达式中的字符是否为数字？
        String digits = "0123456789";
        if(digits.indexOf(ch) == -1) {
            return false;
        } else {
            return true;
        }
    }
    public boolean isOperator(char ch) {      //判断表达式中的字符是否为操作符？
        String operators = "+-*/";
        if(operators.indexOf(ch) == -1) {
            return false;
        } else {
            return true;
        }
    }
    public boolean isParenthese(char ch) {    //判断表达式中的字符是否为小括号？
        String parentheses = "()";
        if(parentheses.indexOf(ch) == -1) {
            return false;
        } else {
            return true;
        }
    }
    private int charCount(char ch) {          //表达式中某个字符的个数
        int count = 0;
        for(int i=0; i<expression.length(); i++) {
            if(expression.charAt(i) == ch) {
                count++;
            }
        }
        return count;
    }
    public boolean isLegal() {                //判断表达式是否合法？
        //检验表达式中是否有不合法的字符
        if(expression.length() == 0) {
            errorMessage = "表达式为空……";
            return false;
        }
        for(int i=0; i<expression.length(); i++) {
            if("0123456789.+-*/()".indexOf(expression.charAt(i))== -1) {
                errorMessage = "表达式中第"+(i+1)+"个字符不合表达式的要求！请仔细检查……";
                return false;
            }
        }
        //检验表达式中括号个数是否匹配
        if(charCount('(') != charCount(')')) {
            errorMessage = "请检查括号个数是否匹配！";
            return false;
        }
        //检验第一个字符和最后一个字符是否合法
        if("-0123456789(".indexOf(expression.charAt(0))==-1 ||
            "0123456789)".indexOf(expression.charAt(expression.length()-1))==-1){
            errorMessage = "请检查第一个字符或者最后一个字符是否合法！";
            return false;
        }
        //检查剩余字符是否合法
        for(int j=1; j<expression.length()-1; j++) {
            //对括号的要求
            if(expression.charAt(j) == '(') {
                if("+-*/(".indexOf(expression.charAt(j-1))==-1 ||
                    "0123456789(-".indexOf(expression.charAt(j+1))==-1) {
                    errorMessage = "表达式中第"+(j+1)+"个字符'('处有错误,请仔细检查……";
                    return false;
                }
            }
            if(expression.charAt(j) == ')') {
                if("+-*/)".indexOf(expression.charAt(j+1))==-1 ||
                    "0123456789)".indexOf(expression.charAt(j-1))==-1) {
                    errorMessage = "表达式中第"+(j+1)+"个字符')'处有错误,请仔细检查……";
                    return false;
                }
            }
            //操作数两边必须为数字
            if(isOperator(expression.charAt(j))) {
                //对于‘-’来说可以是操作符也可以是负号
                if(expression.charAt(j) == '-'
                    && ("0123456789)(".indexOf((expression.charAt(j-1)))!=-1 || "".indexOf((expression.charAt(j-1)))!=-1)
                    && "0123456789(".indexOf(expression.charAt(j+1))!=-1) {
                    continue;
                } else if(expression.charAt(j) == '/' && expression.charAt(j+1) == '0') {
                    errorMessage = "被除数为0是不符合算术运算的……";
                    return false;
                } else {
                    if("0123456789)".indexOf((expression.charAt(j-1)))==-1
                            || "0123456789(".indexOf(expression.charAt(j+1))==-1) {
                        errorMessage = "表达式中第"+(j+1)+"个字符处有错误,请仔细检查……";
                        return false;
                    }
                }
            }
            //对小数点的要求
            if(expression.charAt(j) == '.') {
                if(!isDigit(expression.charAt(j-1)) || !isDigit(expression.charAt(j+1))) {
                    errorMessage = "表达式中第"+(j+1)+"个字符'.'处有错误,请仔细检查……";
                    return false;
                }
            }
        }
        return true;
    }
    public String getErrorMessage() {         //得到表达式的错误信息
        return errorMessage;
    }
    private String value(String str) {        //计算最简表达式的值，不含括号，私有方法
        Stack<Double> staOperand = new Stack<Double>();
        Stack<String> staOperator = new Stack<String>();
        Double res = new Double(0);
        int j = 0;
        if(str.charAt(0) == '-') {
            str = "0"+str;
        }
        for(int i=0; i<str.length(); i++) {
            if(i == str.length()-1) {
                res = new Double(Double.parseDouble(str.substring(j, i+1)));
                staOperand.push(res);
                while(!staOperator.empty()) {
                    double a = staOperand.pop();
                    double b = staOperand.pop();
                    switch(staOperator.pop().charAt(0)) {
                        case '+': res = new Double(a+b); break;
                        case '-': res = new Double(b-a); break;
                        case '*': res = new Double(a*b); break;
                        case '/': res = new Double(b/a); break;
                    }
                    staOperand.push(res);
                }
                break;
            }
            if("+-*/".indexOf(str.charAt(i)) != -1) {
                if(str.charAt(i) == '-') {
                    if("+-*/".indexOf(str.charAt(i-1)) != -1) {
                        j = i;
                        continue;
                    }
                }
                staOperand.push(new Double(Double.parseDouble(str.substring(j, i))));
                j = i+1;

                if(staOperator.empty()) {
                    staOperator.push(str.charAt(i)+"");
                } else {
                    if("*/".indexOf(str.charAt(i))!=-1 && "+-".indexOf(staOperator.peek())!=-1) {
                        staOperator.push(str.charAt(i)+"");
                    }
                    if("*/".indexOf(str.charAt(i))!=-1 && "*/".indexOf(staOperator.peek())!=-1) {
                        double a = staOperand.pop();
                        double b = staOperand.pop();
                        if(staOperator.pop().equals("*")) {
                            res = new Double(a*b);
                        } else {
                            res = new Double(b/a);
                        }
                        staOperator.push(str.charAt(i)+"");
                        staOperand.push(res);
                    }
                    if("+-".indexOf(str.charAt(i))!=-1){
                        double a = staOperand.pop();
                        double b = staOperand.pop();
                        switch(staOperator.pop().charAt(0)) {
                            case '+': res = new Double(a+b); break;
                            case '-': res = new Double(b-a); break;
                            case '*': res = new Double(a*b); break;
                            case '/': res = new Double(b/a); break;
                        }
                        staOperator.push(str.charAt(i)+"");
                        staOperand.push(res);
                    }
                }
            }
        }
        return res+"";
    }
    public String getResult() {               //对表达式进行运算并输出其结果
        String strTemp = expression;
        String resTemp = "0";  //存放临时结果
        int left = 0;
        int right = 0;
        while(strTemp.indexOf(')') != -1) {
            right = strTemp.indexOf(')');
            left = strTemp.substring(0, right).lastIndexOf('(');
            resTemp = value(strTemp.substring(left+1, right));
            strTemp = strTemp.substring(0, left) + resTemp +strTemp.substring(right+1);
        }
        result = value(strTemp);
        return result;
    }
    public String toString() {                //重写toString方法
        return expression;
    }
}

上面代码实现乘除混合运算时还有错误，暂时未能解决……