使用java处理字符串公式运算的方法

　　在改进一个关于合同的项目时，有个需求，就是由于合同中非数据项的计算公式会根据年份而进行变更，而之前是将公式硬编码到系统中的，只要时间一变，系统就没法使用了，因此要求合同中各个非基础数据的项都能自定义公式，根据设置的公式来自动生成报表和合同中的数据。

　　显然定义的公式都是以字符串来存储到数据库的，可是java中没有这种执行字符串公式的工具或者类，而且是公式可以嵌套一个中间公式。比如：基础数据dddd是56，而一个公式是依赖dddd的，eeee=dddd*20,而最终的公式可能是这样：eeee*-12+13-dddd+24。可知eeee是一个中间公式，所以一个公式的计算需要知道中间公式和基础数据。

这好像可以使用一个解释器模式来解决，但是我没有成功，因为括号的优先级是一个棘手的问题，后来又想到可以使用freemarker类似的模板引擎或者java6之后提供的scriptengine 脚本引擎，做了个实验，脚本引擎可以解决，但是这限制了必须使用java6及以上的版本。最终功夫不负有心人，终于找到了完美解决方案，即后缀表达式。我们平时写的公式称作中缀表达式，计算机处理起来比较困难，所以需要先将中缀表达式转换成计算机处理起来比较容易的后缀表达式。

将中缀表达式转换为后缀表达式具体算法规则：见后缀表达式

   a.若为 '('，入栈；

   b.若为 ')'，则依次把栈中的的运算符加入后缀表达式中，直到出现'('，从栈中删除'(' ；

   c.若为 除括号外的其他运算符 ，当其优先级高于栈顶运算符时，直接入栈。否则从栈顶开始，依次弹出比当前处理的运算符优先级高和优先级相等的运算符，直到一个比它优先级低的或者遇到了一个左括号为止。

   ·当扫描的中缀表达式结束时，栈中的的所有运算符出栈；　

我们提出的要求设想是这样的：

public class formulatest {
     @test
     public void testformula() {
         //基础数据
         map<string, bigdecimal> values = new hashmap<string, bigdecimal>();
         values.put("dddd", bigdecimal.valueof(56d));

         //需要依赖的其他公式
         map<string, string> formulas = new hashmap<string, string>();
         formulas.put("eeee", "#{dddd}*20");

         //需要计算的公式
         string expression = "#{eeee}*-12+13-#{dddd}+24";

         bigdecimal result = formulaparser.parse(expression, formulas, values);
         assert.assertequals(result, bigdecimal.valueof(-13459.0));
     }
 }

以下就是解决问题的步骤：

1、首先将所有中间变量都替换成基础数据

formulaparser的finalexpression方法会将所有的中间变量都替换成基础数据,就是一个递归的做法

public class formulaparser {
     /**
      * 匹配变量占位符的正则表达式
      */
     private static pattern pattern = pattern.compile("\\#\\{(.+?)\\}");

     /**
      * 解析公式，并执行公式计算
      *
      * @param formula
      * @param formulas
      * @param values
      * @return
      */
     public static bigdecimal parse(string formula, map<string, string> formulas, map<string, bigdecimal> values) {
         if (formulas == null)formulas = collections.emptymap();
         if (values == null)values = collections.emptymap();
         string expression = finalexpression(formula, formulas, values);
         return new calculator().eval(expression);
     }

     /**
      * 解析公式，并执行公式计算
      *
      * @param formula
      * @param values
      * @return
      */
     public static bigdecimal parse(string formula, map<string, bigdecimal> values) {
         if (values == null)values = collections.emptymap();
         return parse(formula, collections.<string, string> emptymap(), values);
     }

     /**
      * 解析公式，并执行公式计算
      *
      * @param formula
      * @return
      */
     public static bigdecimal parse(string formula) {
         return parse(formula, collections.<string, string> emptymap(), collections.<string, bigdecimal> emptymap());
     }

     /**
      * 将所有中间变量都替换成基础数据
      *
      * @param expression
      * @param formulas
      * @param values
      * @return
      */
     private static string finalexpression(string expression, map<string, string> formulas, map<string, bigdecimal> values) {
         matcher m = pattern.matcher(expression);
         if (!m.find())return expression;

         m.reset();

         stringbuffer buffer = new stringbuffer();
         while (m.find()) {
             string group = m.group(1);
             if (formulas != null && formulas.containskey(group)) {
                 string formula = formulas.get(group);
                 m.appendreplacement(buffer, '(' + formula + ')');
             } else if (values != null && values.containskey(group)) {
                 bigdecimal value = values.get(group);
                 m.appendreplacement(buffer,value.toplainstring());
             }else{
                 throw new illegalargumentexception("expression '"+expression+"' has a illegal variable:"+m.group()+",cause veriable '"+group+"' not being found in formulas or in values.");
             }
         }
         m.appendtail(buffer);
         return finalexpression(buffer.tostring(), formulas, values);
     }
 }

2、将中缀表达式转换为后缀表达式

　　calculator的infix2suffix将中缀表达式转换成了后缀表达式

3、计算后缀表达式

　　calculator的evalinfix计算后缀表达式

public class calculator{
     private static log logger = logfactory.getlog(calculator.class);

     /**
      * 左括号
      */
     public final static char left_bracket = '(';

     /**
      * 右括号
      */
     public final static char right_bracket = ')';

     /**
      * 中缀表达式中的空格，需要要忽略
      */
     public final static char blank = ' ';

     /**
      * 小数点符号
      */
     public final static char decimal_point = '.';

     /**
      * 负号
      */
     public final static char negative_sign = '-';

     /**
      * 正号
      */
     public final static char positive_sign = '+';

     /**
      * 后缀表达式的各段的分隔符
      */
     public final static char separator = ' ';

     /**
      * 解析并计算表达式
      *
      * @param expression
      * @return
      */
     public bigdecimal eval(string expression) {
         string str = infix2suffix(expression);
         logger.info("infix expression: " + expression);
         logger.info("suffix expression: " + str);
         if (str == null) {
             throw new illegalargumentexception("infix expression is null!");
         }
         return evalinfix(str);
     }

     /**
      * 对后缀表达式进行计算
      *
      * @param expression
      * @return
      */
     private bigdecimal evalinfix(string expression) {
         string[] strs = expression.split("\\s+");
         stack<string> stack = new stack<string>();
         for (int i = 0; i < strs.length; i++) {
             if (!operator.isoperator(strs[i])) {
                 stack.push(strs[i]);
             } else {
                 operator op = operator.getinstance(strs[i]);
                 bigdecimal right =new bigdecimal(stack.pop());
                 bigdecimal left =new bigdecimal(stack.pop());
                 bigdecimal result = op.eval(left, right);
                 stack.push(string.valueof(result));
             }
         }
         return new bigdecimal(stack.pop());
     }

     /**
      * 将中缀表达式转换为后缀表达式<br>
      * 具体算法规则 81      * 1)计算机实现转换： 将中缀表达式转换为后缀表达式的算法思想：
      *     开始扫描；
      *         数字时，加入后缀表达式；
      *         运算符：
      *  a.若为 '('，入栈；
      *  b.若为 ')'，则依次把栈中的的运算符加入后缀表达式中，直到出现'('，从栈中删除'(' ；
      *  c.若为 除括号外的其他运算符 ，当其优先级高于栈顶运算符时，直接入栈。否则从栈顶开始，依次弹出比当前处理的运算符优先级高和优先级相等的运算符，直到一个比它优先级低的或者遇到了一个左括号为止。
      *  ·当扫描的中缀表达式结束时，栈中的的所有运算符出栈；　
      *
      * @param expression
      * @return
      */
     public string infix2suffix(string expression) {
         if (expression == null) return null;

         stack<character> stack = new stack<character>();

         char[] chs = expression.tochararray();
         stringbuilder sb = new stringbuilder(chs.length);

         boolean appendseparator = false;
         boolean sign = true;
         for (int i = 0; i < chs.length; i++) {
             char c = chs[i];

             // 空白则跳过
             if (c == blank)continue;

             // next line is used output stack information.
             // system.out.printf("%-20s %s%n", stack, sb.tostring());

             // 添加后缀表达式分隔符
             if (appendseparator) {
                 sb.append(separator);
                 appendseparator = false;
             }

             if (issign(c) && sign) {
                 sb.append(c);
             } else if (isnumber(c)) {
                 sign = false;// 数字后面不是正号或负号，而是操作符+-
                 sb.append(c);
             } else if (isleftbracket(c)) {
                 stack.push(c);
             } else if (isrightbracket(c)) {
                 sign = false;

                 // 如果为)，则弹出(上面的所有操作符，并添加到后缀表达式中，并弹出(
                 while (stack.peek() != left_bracket) {
                     sb.append(separator).append(stack.pop());
                 }
                 stack.pop();
             } else {
                 appendseparator = true;
                 if (operator.isoperator(c)) {
                     sign = true;

                     // 若为(则入栈
                     if (stack.isempty() || stack.peek() == left_bracket) {
                         stack.push(c);
                         continue;
                     }
                     int precedence = operator.getprority(c);
                     while (!stack.isempty() && operator.getprority(stack.peek()) >= precedence) {
                         sb.append(separator).append(stack.pop());
                     }
                     stack.push(c);
                 }
             }
         }
         while (!stack.isempty()) {
             sb.append(separator).append(stack.pop());
         }
         return sb.tostring();
     }

     /**
      * 判断某个字符是否是正号或者负号
      *
      * @param c
      * @return
      */
     private boolean issign(char c) {
         return (c == negative_sign || c == positive_sign);
     }

     /**
      * 判断某个字符是否为数字或者小数点
      *
      * @param c
      * @return
      */
     private boolean isnumber(char c) {
         return ((c >= '0' && c <= '9') || c == decimal_point);
     }

     /**
      * 判断某个字符是否为左括号
      *
      * @param c
      * @return
      */
     private boolean isleftbracket(char c) {
         return c == left_bracket;
     }

     /**
      * 判断某个字符是否为右括号
      *
      * @param c
      * @return
      */
     private boolean isrightbracket(char c) {
         return c == right_bracket;
     }

最后把操作符类贴上

view code
 public abstract class operator {
     /**
      * 运算符
      */
     private char operator;

     /**
      * 运算符的优先级别，数字越大，优先级别越高
      */
     private int priority;

     private static map<character, operator> operators = new hashmap<character, operator>();

     private operator(char operator, int priority) {
         setoperator(operator);
         setpriority(priority);
         register(this);
     }

     private void register(operator operator) {
         operators.put(operator.getoperator(), operator);
     }

     /**
      * 加法运算
      */
     public final static operator adition = new operator('+', 100) {
         public bigdecimal eval(bigdecimal left, bigdecimal right) {
             return left.add(right);
         }
     };

     /**
      * 减法运算
      */
     public final static operator subtration = new operator('-', 100) {
         public bigdecimal eval(bigdecimal left, bigdecimal right) {
             return left.subtract(right);
         }
     };

     /**
      * 乘法运算
      */
     public final static operator multiplication = new operator('*', 200) {
         public bigdecimal eval(bigdecimal left, bigdecimal right) {
             return left.multiply(right);
         }
     };

     /**
      * 除法运算
      */
     public final static operator divition = new operator('/', 200) {
         public bigdecimal eval(bigdecimal left, bigdecimal right) {
             return left.divide(right);
         }
     };

     /**
      * 冪运算
      */
     public final static operator exponent = new operator('^', 300) {
         public bigdecimal eval(bigdecimal left, bigdecimal right) {
             return left.pow(right.intvalue());
         }
     };

     public char getoperator() {
         return operator;
     }

     private void setoperator(char operator) {
         this.operator = operator;
     }

     public int getpriority() {
         return priority;
     }

     private void setpriority(int priority) {
         this.priority = priority;
     }

     /**
      * 根据某个运算符获得该运算符的优先级别
      *
      * @param c
      * @return 运算符的优先级别
      */
     public static int getprority(char c) {
         operator op = operators.get(c);
         return op != null ? op.getpriority() : 0;
     }

     /**
      * 工具方法，判断某个字符是否是运算符
      *
      * @param c
      * @return 是运算符返回 true，否则返回 false
      */
     public static boolean isoperator(char c) {
         return getinstance(c) != null;
     }

     public static boolean isoperator(string str) {
         return str.length() > 1 ? false : isoperator(str.charat(0));
     }

     /**
      * 根据运算符获得 operator 实例
      *
      * @param c
      * @return 从注册中的 operator 返回实例，尚未注册返回 null
      */
     public static operator getinstance(char c) {
         return operators.get(c);
     }

     public static operator getinstance(string str) {
         return str.length() > 1 ? null : getinstance(str.charat(0));
     }

     /**
      * 根据操作数进行计算
      *
      * @param left
      *            左操作数
      * @param right
      *            右操作数
      * @return 计算结果
      */
     public abstract bigdecimal eval(bigdecimal left, bigdecimal right);