java中的布尔表达式解析器

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

我的意思是这样表达的：

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

T&&（F | |（F&&T））

可以将其分解为表达式树，以显示哪个标记导致了“F”值，如下所示（可能类似于以下内容）：

T&&您可以使用或执行此操作。两者都是表达式语言库，下面的示例使用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));

Map context=newjava.util.HashMap（）；
上下文。put（“T”，true）；
上下文。放置（“F”，假）；
System.out.println（MVEL.eval（“T&&（F&&T）），上下文）；

印刷品：
错误
签出。它具有接受类似Java语法的表达式解析

编辑：除非您试图从字面上解析
T&&F
，尽管您可以在BeanShell中使用文本
true
和
false
来完成此操作。

这并不完全是你想要的结果，但我认为这可能是一个起点

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

封装测试；
导入java.util.ArrayList；
导入java.util.Iterator；
导入java.util.List；
导入net.astesana.javaluator.*；
公共类TreeBooleanEvaluator扩展AbstractEvaluator{
/**逻辑AND运算符*/
最终静态运算符和=新运算符（&&），2，Operator.Associativity.LEFT，2）；
/**逻辑OR运算符*/
最终静态运算符或=新运算符（“| |”，2，Operator.Associativity.LEFT，1）；
私有静态最终参数；
静止的{
//创建计算器的参数
参数=新参数（）；
//添加支持的运算符
参数。添加（和）；
参数。添加（或）；
//加上括号
参数.加法表达式括号（括号对.括号）；
}
公共树木评估器（）{
超级（参数）；
}
@凌驾
受保护的字符串toValue（字符串文字、对象evaluationContext）{
返回文本；
}
私有布尔getValue（字符串文字）{
如果（“T”.equals（literal）| literal.endsWith（“=true”））返回true；
else如果（“F”.equals（literal）| literal.endsWith（“=false”））返回false；
抛出新的IllegalArgumentException（“未知文字：+literal”）；
}
@凌驾
受保护的字符串求值（运算符、迭代器操作数、，
对象求值（上下文）{
列表树=（列表）evaluationContext；
字符串o1=操作数。下一步（）；
字符串o2=操作数。下一步（）；
布尔结果；
if（运算符==或）{
结果=getValue（o1）| getValue（o2）；
}else if（运算符==和）{
结果=getValue（o1）和getValue（o2）；
}否则{
抛出新的IllegalArgumentException（）；
}
字符串eval=“（“+o1+”+operator.getSymbol（）+”“+o2+”””+结果；
树。添加（eval）；
返回评估；
}
公共静态void main（字符串[]args）{
TreeBooleanEvaluator=新的TreeBooleanEvaluator（）；
doIt（评估员，“T&&（F&（F&&T））”；
doIt（评估者，“（T&T）|（F&T）”；
}
私有静态void doIt（TreeBooleanEvaluator求值器，字符串表达式）{
列表序列=新的ArrayList（）；
评估器。评估（表达式、序列）；
System.out.println（“表达式的求值顺序”）；
for（字符串：序列）{
System.out.println（字符串）；
}
System.out.println（）；
}
}

以下是输出：

评估顺序为：T&&（F | |（F&&T））

（F&T）=假

（F | |（F&T）=假）=假

（T&&（F&&T）|（F&&T）=假）=假）=假

（T&&T）|（F&&T）的评估顺序

（T&T）=正确

（F&T）=假

（（T&T）=真| |（F&T）=假）=真

我最近用Java编写了一个库，专门用来处理布尔表达式：

它包括一个用于解析字符串外输入表达式的工具：

Expression<String> expr = ExprParser.parse("( ( (! C) | C) & 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);

并非100%符合您的要求，但希望能有所帮助。
处理布尔运算符-请找到几个示例

例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

欲知更多详情，请点击

致以最诚挚的问候
很酷，我很快就会尝试，如果这是我想要做的，我会接受+1我修复了几个bug，但总体上是有想法的。谢谢
import org.mariuszgromada.math.mxparser.*;
...
...
Expression e = new Expression("1 && (0 || (0 && 1))");
System.out.println(e.getExpressionString() + " = " + e.calculate());

1 && (0 || (0 && 1)) = 0.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