JAVA - 表达式解析和评估库答案

【问题标题】：JAVA - Expression parsing & evaluating libraryJAVA - 表达式解析和评估库
【发布时间】：2012-08-14 07:21:01
【问题描述】：

我正在寻找一个 JAVA 库来解析和评估表达式。我搜索并尝试了一些库，如 Apache 的 JEXL 和 Jeval，但它们并不是我所需要的。

我的要求：

支持所有值类型（即 int、double、boolean、String 等）
支持所有已知的数学和逻辑运算符（+、-、*、
支持变量（没有任何特殊符号 - 例如在 Jeval 中，变量 a 应该写成 #{a} - 对我来说不够好）
支持自定义函数 - 具有类型强制和验证

有什么建议吗？

【问题讨论】：

你考虑过内置的Java Script引擎吗？

标签： java expression

【解决方案1】：

试试Janino。它是一个运行时内存编译器，可用作表达式求值器。也许这对你来说是正确的。

【讨论】：

这确实是一个令人印象深刻的图书馆，至少从他们声称能够做到的事情来看

【解决方案2】：

如建议的那样，您可以使用 JavaScript。但是您也可以查看Spring EL，它支持您的要求。

【讨论】：

【解决方案3】：

您可以尝试mXparser - 它支持您的大部分需求：

它基于double，所以支持int，另外支持boolean为true = 1和false = 0。不幸的是不支持字符串。

布尔示例：

import org.mariuszgromada.math.mxparser.*;
...
...
Constant T = new Constant("T = 1");
Constant F = new Constant("F = 0");
Expression e = new Expression("T && (F || (F && T))", T, F);
System.out.println(e.getExpressionString() + " = " + e.calculate());

结果：

T && (F || (F && T)) = 0.0

mXparser 广泛支持运算符、函数等。请查看mXparser math collection。您可以在库中使用帮助功能有什么好处。

例子：

import org.mariuszgromada.math.mxparser.*;
...
...
mXparser.consolePrintHelp("operator");

结果：

Help content: 

    2. +                   <Operator>              addition
    3. -                   <Operator>              subtraction
    4. *                   <Operator>              multiplication
    5. /                   <Operator>              division
    6. ^                   <Operator>              exponentiation
    7. !                   <Operator>              factorial
    8. #                   <Operator>              modulo function
    9. &                   <Boolean Operator>      logical conjunction (AND)
   10. &&                  <Boolean Operator>      logical conjunction (AND)
   11. /\                  <Boolean Operator>      logical conjunction (AND)
   12. ~&                  <Boolean Operator>      NAND - Sheffer stroke
   13. ~&&                 <Boolean Operator>      NAND - Sheffer stroke
   14. ~/\                 <Boolean Operator>      NAND - Sheffer stroke
   15. |                   <Boolean Operator>      logical disjunction (OR)
   16. ||                  <Boolean Operator>      logical disjunction (OR)
   17. \/                  <Boolean Operator>      logical disjunction (OR)
   18. ~|                  <Boolean Operator>      logical NOR
   19. ~||                 <Boolean Operator>      logical NOR
   20. ~\/                 <Boolean Operator>      logical NOR
   21. (+)                 <Boolean Operator>      exclusive or (XOR)
   22. -->                 <Boolean Operator>      implication (IMP)
   23. <--                 <Boolean Operator>      converse implication (CIMP)
   24. -/>                 <Boolean Operator>      material nonimplication (NIMP)
   25. </-                 <Boolean Operator>      converse nonimplication (CNIMP)
   26. <->                 <Boolean Operator>      logical biconditional (EQV)
   27. ~                   <Boolean Operator>      negation
   28. ¬                   <Boolean Operator>      negation
  162. add                 <Variadic Function>     (2.4) Summation operator add(a1,a2,a3,...,an)
  168. sum                 <Calculus Operator>     summation operator (SIGMA) sum(i, from, to, f(i,...))
  169. prod                <Calculus Operator>     product operator (PI) prod(i, from, to, f(i,...))
  170. int                 <Calculus Operator>     definite integral operator ( int(f(x,...), x, a, b) )
  171. der                 <Calculus Operator>     derivative operator ( der(f(x,...), x) ) 
  172. der-                <Calculus Operator>     left derivative operator ( der-(f(x,...), x) ) 
  173. der+                <Calculus Operator>     right derivative operator ( der+(f(x,...), x) ) 
  174. dern                <Calculus Operator>     n-th derivative operator ( dern(f(x,...), x) ) 
  175. diff                <Calculus Operator>     forward difference operator
  176. difb                <Calculus Operator>     backward difference operator
  177. avg                 <Calculus Operator>     (2.4) Average operator avg(i, from, to, f(i,...))
  178. vari                <Calculus Operator>     (2.4) Bias-corrected sample variance operator vari(i, from, to, f(i,...))
  179. stdi                <Calculus Operator>     (2.4) Bias-corrected sample standard deviation operator stdi(i, from, to, f(i,...))
  180. mini                <Calculus Operator>     (2.4) Minimum value mini(i, from, to, f(i,...))
  181. maxi                <Calculus Operator>     (2.4) Maximum value maxi(i, from, to, f(i,...))
  182. solve               <Calculus Operator>     (4.0) f(x) = 0 equation solving, function root finding: solve( f(x,...), x, a, b )
  301. @~                  <Bitwise Operator>      (4.0) Bitwise unary complement
  302. @&                  <Bitwise Operator>      (4.0) Bitwise AND
  303. @^                  <Bitwise Operator>      (4.0) Bitwise exclusive OR
  304. @|                  <Bitwise Operator>      (4.0) Bitwise inclusive OR
  305. @<<                 <Bitwise Operator>      (4.0) Signed left shift
  306. @>>                 <Bitwise Operator>      (4.0) Signed right shift

用户定义的变量和用户定义的常量是在没有任何特殊形式的情况下创建的。

例子：

import org.mariuszgromada.math.mxparser.*;
...
...
Argument x = new Argument("x = 10");
Constant y = new Constant("y = 2");
Expression e = new Expression("x/y", x, y);
System.out.println(e.getExpressionString() + " = " + e.calculate());

结果：

x/y = 5.0

另外请检查：a）Tutorial - User defined arguments，b）Tutorial - User defined constants。

完全支持用户定义的函数。

示例 1 - 在运行时定义的主体：

import org.mariuszgromada.math.mxparser.*;
...
...
Function f = new Function("f(x,y) = x*y");
Expression e = new Expression("20-f(2,5)",f);
System.out.println(e.getExpressionString() + " = " + e.calculate());

结果 1

20-f(2,5) = 10.0

示例 2 - 通过您自己的实现扩展主体：

import org.mariuszgromada.math.mxparser.*;
...
...
/*
 * Implementing FunctionExtension interface
 */
public class Addition implements FunctionExtension {
   double x;
   double y;
   public Addition() {
      x = Double.NaN;
      y = Double.NaN;
   }
   public Addition(double x, double y) {
      this.x = x;
      this.y = y;
   }
   public int getParametersNumber() {
      return 2;
   }
   public void setParameterValue(int argumentIndex, double argumentValue) {
      if (argumentIndex == 0) x = argumentValue;
      if (argumentIndex == 1) y = argumentValue;
   }
   public double calculate(double... params) {
      return x+y;
   }
   public FunctionExtension clone() {
      return new Addition(x, y);
   }   
}

/*
* Creating extended function
*/
Function f = new Function("f", new Addition());
mXparser.consolePrintln("f.calculate(1,2) = " + f.calculate(1,2) );
/*
* Using extended function in expression
*/
Expression e = new Expression("f(2,3)", f);
System.out.println(e.getExpressionString() + " = " + e.calculate() );

结果 2：

f.calculate(1,2) = 3.0
f(2,3) = 5.0

另外值得关注一下mXparser Tutorial.

最近发现 - 如果您想尝试语法（并查看高级用例），您可以下载由 mXparser 提供支持的 Scalar Calculator app。

最好的问候

【讨论】：

很遗憾，它不支持 pow。
@ShoaibChikate 您可以简单地写 x^y - 这与 pow(x,y) 相同

【解决方案4】：

如果您没有找到实际的 Java 表达式评估库，您可以选择以下几种解决方法：

使用 XPath 评估您的表达式。
- 优点：XPath 知道逻辑运算符，您可以使用 Xalan 的扩展来实现变量和自定义函数
- 缺点：XPath 的类型比 Java 少
使用 JavaScript 评估您的表达式。
- 优点：Javascript 非常灵活，并且在您的要求严格时仍然适用。您也可以使用 Javascript 实现变量和自定义函数
- 缺点：Javascript 的类型比 Java 少
使用 JSP 的表达式语言评估您的表达式（例如使用 JUEL）

【讨论】：