字符串运算式的计算

　　最近一次在重构过程中，遇到一个功能，它实现对字符串表达式的计算，对类似 (a+b)*c 这种表达式进行实时计算，老的方式采用分割字符串的方式来实现，经常出错，我改写了一下。采用了几种方式。在此记录下来。

1.正则分组

使用正则的组匹配类似于 ((.+))(.+) 匹配之后结果为

根据正则组的顺序来计算。

但是对于这种也是有很多缺点的，一旦表达式复杂起来，正则将变得异常复杂和难以调试。而且，这种方式也必须事先规定字符串的格式。

2.后缀表达式

我们平时写的这种 (a+b)*c 表达式叫做中缀表达式，与之相对的有前缀表达式和后缀表达式，后缀表达式也叫逆波兰式。

它的原理是将数字计算符后移，并将括号中的运算符至于前面，即不使用括号来保证运算顺序的一种方式，这种方式很适合计算机运算。

例如，将中缀表达式“1+((2+3)×4)-5”转换为后缀表达式的过程如下：

扫描到的元素	S2(栈底->栈顶)	S1 (栈底->栈顶)	说明
1	1	空	数字，直接入栈
+	1	+	S1为空，运算符直接入栈
(	1	+ (	左括号，直接入栈
(	1	+ ( (	同上
2	1 2	+ ( (	数字
+	1 2	+ ( ( +	S1栈顶为左括号，运算符直接入栈
3	1 2 3	+ ( ( +	数字
)	1 2 3 +	+ (	右括号，弹出运算符直至遇到左括号
×	1 2 3 +	+ ( ×	S1栈顶为左括号，运算符直接入栈
4	1 2 3 + 4	+ ( ×	数字
)	1 2 3 + 4 ×	+	右括号，弹出运算符直至遇到左括号
-	1 2 3 + 4 × +	-	-与+优先级相同，因此弹出+，再压入-
5	1 2 3 + 4 × + 5	-	数字
到达最右端	1 2 3 + 4 × + 5 -	空	S1中剩余的运算符

因此结果为“1 2 3 + 4 × + 5 -”（注意需要逆序输出）。

详细原理参考：http://blog.csdn.net/antineutrino/article/details/6763722/

在对比一系列实现之后，这里我使用栈来实现这种方式。

package suffixformular;

import java.util.Collections;
import java.util.Stack;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Pattern;

import javax.script.ScriptException;

/**
 * 后缀表达式原理
 */
public class SuffixFormula {

    private static SuffixFormula instance = new SuffixFormula();

    private SuffixFormula() {
    }

    public static SuffixFormula getInstnace() {
        return instance;
    }

    private Stack transformToSuffix(String infix) {
        InToPost inToPost = new InToPost(infix);
        return inToPost.doTrans();
    }

    public void c(Stack<Double> sk, String ch) {
        switch (ch) {
        case "+":
            try {
                sk.push(sk.pop() + sk.pop());
            } catch (Exception e) {
                e.printStackTrace();
            }
            break;
        case "-":
            double tmp = sk.pop();
            sk.push(sk.pop() - tmp);
            break;
        case "*":
            sk.push(sk.pop() * sk.pop());
            break;
        case "/":
            double temp = sk.pop();
            sk.push(sk.pop() / temp);
            break;
        case "^":
            double tp = sk.pop();
            sk.push(Math.pow(sk.pop(), tp));
            break;
        case "%":
            double mp = sk.pop();
            sk.push(sk.pop() % mp);
            break;

        default:
            throw new RuntimeException();
        }
    }

    // 完整版
    public double formula(String infix) {
        Stack result = new Stack<Double>();
        Stack suffix = transformToSuffix(infix);
        Collections.reverse(suffix);
        Pattern pattern = Pattern.compile("[0-9]*");
        // ①
        while (!suffix.isEmpty()) {
            String str = String.valueOf(suffix.pop());
            if (pattern.matcher(str).matches()) {
                double dou = Double.parseDouble(str);
                result.push(dou);
            } else {
                c(result, str);
            }
        }
        return (double) result.pop();

    }

    public static void main(String[] args)  {
        String abc = "2^((4+2)/3)"; //"1+((2+3)*4)-5";//

        double value = // 0;
        SuffixFormula.getInstnace().formula(abc);

        System.err.println(value);
    }

}

class InToPost {
    private Stack stack;
    private String input;// 输入中缀表达式
    private Stack output;// 输出的后缀表达式

    public InToPost(String input) {
        this.input = input;
        int size = input.length();
        stack = new Stack<Object>();
        output = new Stack<Object>();
    }

    public Stack doTrans() {// 转换为后缀表达式方法
        boolean ischar = false;
        for (int i = 0; i < input.length(); i++) {
            char ch = input.charAt(i);
            if (ch == ' ') {
                continue;
            } 
            //负号部分，未测试
//            else if (ch == '-' && (output.size()<=0 || ischar)) {
//                output.push(ch);
//
//                ischar = false;
//                continue;
//            }
            switch (ch) {
            case '+':
            case '-':
                getOper(ch, 1);
                ischar = true;
                break;
            case '*':
            case '/':
            case '%':
                getOper(ch, 2);
                ischar = true;
                break;
            case '^':
                getOper(ch, 3);
                ischar = true;
                break;
            case '(':
                stack.push(ch);
                ischar = true;
                break;
            case ')':
                getParent(ch);
                ischar = true;
                break;
            default:
                output.push(ch);

                ischar = false;
                break;
            }
        }
        while (!stack.isEmpty()) {
            output.push(stack.pop());
        }

        return output;
    }

    public void getParent(char ch) {
        while (!stack.isEmpty()) {
            char chx = (char) stack.pop();
            if (chx == '(') {
                break;
            } else {
                output.push(chx);
            }
        }
    }

    public void getOper(char ch, int prec1) {
        while (!stack.isEmpty()) {// 判断栈是否为空
            char operTop = (char) stack.pop();
            if (operTop == '(') {
                stack.push(operTop);
                break;
            } else {
                int prec2 = 0;
                if (operTop == '+' || operTop == '-') {
                    prec2 = 1;
                } else if (operTop == '*' || operTop == '/') {
                    prec2 = 2;
                } else if (operTop == '^') {
                    prec2 = 3;
                }
                if (prec2 < prec1) {
                    stack.push(operTop);
                    break;
                } else {
                    output.push(operTop);
                }
            }
        }
        stack.push(ch);
    }
}

 这段代码没有优化

稍微与实际有所不同的是我贴出的实现只能计算单个数字，比如 (2+3)*6。如果需要计算更高位的数字，可以先使用 (a+b)*c ，待后缀表达式转换完成，在①处用实际数字来替换a,b,c占位符即可。

实际上关于后缀表达式的实现还有一种更简单的方式，例如：

a+b*c-(d+e)

第一步：按照运算符的优先级对所有的运算单位加括号~
        式子变成拉：((a+(b*c))-(d+e))
第二步：转换前缀与后缀表达式
        前缀：把运算符号移动到对应的括号前面
              则变成拉：-( +(a *(bc)) +(de))
              把括号去掉：-+a*bc+de  前缀式子出现
        后缀：把运算符号移动到对应的括号后面
              则变成拉：((a(bc)* )- (de)+ )-
              把括号去掉：abc*-de+-  后缀式子出现

这里只做参考，没有实现。具体参见：http://blog.sina.com.cn/s/blog_4e0c21cc01010x38.html

3.使用JDK自带的脚本解释器。

      static ScriptEngine jse = new ScriptEngineManager().getEngineByName("JavaScript");

    public static void main(String[] args) throws ScriptException {
        String abc = "(1+7)%3";//"2^((4+2)/3)";
    
//        double value =  // 0;
//                SuffixFormula.getInstnace().formula(abc);
        
        Object value2=jse.eval(abc);
    
        System.err.println("eval:"+value2);
    }

需要注意的是java实现的javascript脚本解释器，只支持javascript的运算模式，像^是不支持的必须使2^2这种个就会出错，需要用Math.pow()这种javascript的函数。另外这种脚本解释器只有在JDK6以上才有，低版本是没有的。

对于简单的我推荐使用方法3.一般使用方法2.