Question

是否有任何java库或技术可以逐步解析布尔表达式？

我的意思是给出一个这样的表达式：

T && ( F || ( F && T ) )

它可以分解为表达式树来显示哪个令牌导致'F'值，就像这样（可能这样的东西）：

T &&               <- rhs false
    ( F ||         <- rhs false
        ( F && T ) <- eval, false
    )

我正在尝试将布尔表达式评估传达给非程序员。我和Anlr在一起，但是我无法做到这一点（似乎有一点学习曲线）。

我不反对自己写，但我宁愿不重新发明轮子。

Answer 1

我使用Javaluator对此进行了编码它并不完全是您正在寻找的输出，但我认为它可能是一个起点。

package test;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import net.astesana.javaluator.*;

public class TreeBooleanEvaluator extends AbstractEvaluator<String> {
  /** The logical AND operator.*/
  final static Operator AND = new Operator("&&", 2, Operator.Associativity.LEFT, 2);
  /** The logical OR operator.*/
  final static Operator OR = new Operator("||", 2, Operator.Associativity.LEFT, 1);

  private static final Parameters PARAMETERS;

  static {
    // Create the evaluator's parameters
    PARAMETERS = new Parameters();
    // Add the supported operators
    PARAMETERS.add(AND);
    PARAMETERS.add(OR);
    // Add the parentheses
    PARAMETERS.addExpressionBracket(BracketPair.PARENTHESES);
  }

  public TreeBooleanEvaluator() {
    super(PARAMETERS);
  }

  @Override
  protected String toValue(String literal, Object evaluationContext) {
    return literal;
  }

  private boolean getValue(String literal) {
    if ("T".equals(literal) || literal.endsWith("=true")) return true;
    else if ("F".equals(literal) || literal.endsWith("=false")) return false;
    throw new IllegalArgumentException("Unknown literal : "+literal);
  }

  @Override
  protected String evaluate(Operator operator, Iterator<String> operands,
      Object evaluationContext) {
    List<String> tree = (List<String>) evaluationContext;
    String o1 = operands.next();
    String o2 = operands.next();
    Boolean result;
    if (operator == OR) {
      result = getValue(o1) || getValue(o2);
    } else if (operator == AND) {
      result = getValue(o1) && getValue(o2);
    } else {
      throw new IllegalArgumentException();
    }
    String eval = "("+o1+" "+operator.getSymbol()+" "+o2+")="+result;
    tree.add(eval);
    return eval;
  }

  public static void main(String[] args) {
    TreeBooleanEvaluator evaluator = new TreeBooleanEvaluator();
    doIt(evaluator, "T && ( F || ( F && T ) )");
    doIt(evaluator, "(T && T) || ( F && T )");
  }

  private static void doIt(TreeBooleanEvaluator evaluator, String expression) {
    List<String> sequence = new ArrayList<String>();
    evaluator.evaluate(expression, sequence);
    System.out.println ("Evaluation sequence for :"+expression);
    for (String string : sequence) {
      System.out.println (string);
    }
    System.out.println ();
  }
}

这是输出：

评估顺序：T＆amp;＆amp; （F ||（F＆amp; T））
  （F＆amp; T）=假
  （F ||（F＆amp;＆amp; T）= false）=假
  （T＆amp;＆amp;（F ||（F＆amp;＆amp; T）= false）= false）= false

评估顺序为：（T＆amp;＆amp; T）|| （F＆amp; T）
  （T＆amp; T）=真
  （F＆amp; T）=假
  （（T＆amp; T）=真||（F＆amp; T）=假）=真

Answer 2

您可以使用MVEL或JUEL执行此操作。两者都是表达式语言库，下面的示例使用MVEL。

示例：

System.out.println(MVEL.eval("true && ( false || ( false && true ) )"));

打印：假

如果你真的想要使用'T'和'F'，你可以这样做：

Map<String, Object> context = new java.util.HashMap<String, Object>();
context.put("T", true);
context.put("F", false);
System.out.println(MVEL.eval("T && ( F || ( F && T ) )", context));

打印：假

Answer 3

我最近专门用Java编写了一个库来操作布尔表达式：jbool_expressions。

它包含一个工具，它也解析了字符串输入中的表达式：

Expression<String> expr = ExprParser.parse("( ( (! C) | C) & A & B)")

你也可以做一些相当简单的简化：

Expression<String> simplified = RuleSet.simplify(expr);
System.out.println(expr);

给出

(A & B)

如果您想逐步完成任务，可以逐个分配值。对于此处的示例，

Expression<String> halfAssigned = RuleSet.assign(simplified, Collections.singletonMap("A", true));
System.out.println(halfAssigned);

显示

你可以通过分配B来解决它。

Expression<String> resolved = RuleSet.assign(halfAssigned, Collections.singletonMap("B", true));
System.out.println(resolved);

显示

true

不是100％你所要求的，但希望它有所帮助。

Answer 4

结帐BeanShell。它具有接受类似Java语法的表达式解析。

编辑：除非您尝试实际解析T && F，否则您可以使用文字true和false在BeanShell中执行此操作。< / p>

Answer 5

mXparser处理布尔运算符 - 请找几个例子

示例1：

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

结果1：

1 && (0 || (0 && 1)) = 0.0

示例2：

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());

结果2：

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

有关详细信息，请关注mXparser tutorial。

祝你好运

java中的布尔表达式解析器

5 个答案: