Java 在运行时计算一系列布尔条件是否有效

我有一个布尔条件列表，比如

==4

，

<5

，

>1

等等。现在我想知道的是，一系列的限制条件是否可行。假设

<5>1

是可能的，而

<5>9

不是。我曾想过把弦线插入纳肖恩，但这毫无意义。我怎样才能做到这一点？或者有没有图书馆在做这项工作

---

编辑：我有3个运算符==，=和double not integer（是的，在现实生活中，较小或较大的运算符表示较小/较大的等于-但这不应该有什么区别）。也许我可以放大倍数，即1022.30->10223

我会为操作符使用

接口，而不是
枚举。这将使您能够为所有操作员创建此接口的子类：

// File: Main.java
import java.util.ArrayList;
import java.util.List;

class Pair<L,R> {
    L left;
    R right;

    public Pair(L left, R right) {
        this.left = left;
        this.right = right;
    }
}

interface Operator {

    boolean calculate(double lhs, double rhs);
}

public class Main {

    private static Operator equals = new Operator() {

        @Override
        public boolean calculate(double lhs, double rhs) {
            return lhs == rhs;
        }

        @Override
        public String toString() {
            return "==";
        }
    };



    public static void main(String[] args) {

        Double x = 3.14;

        List<Pair<Operator, Double>> constraints = new ArrayList<>();
        constraints.add(new Pair(equals, 5.0));
        constraints.add(new Pair(equals, 3.14));

        for (Pair<Operator, Double> constraint : constraints) {

            Operator operator = constraint.left;
            double value = constraint.right;

            boolean result = operator.calculate(x, value);

            System.out.println(x + operator.toString() + value + "=" + result);
        }
    }
}

//文件：Main.java
导入java.util.ArrayList；
导入java.util.List；
类对{
我走了；
R权利；
公共对（左左，右）{
this.left=左；
这个。右=右；
}
}
接口运算符{
布尔运算（双左、双右）；
}
公共班机{
私有静态运算符等于=新运算符（）{
@凌驾
公共布尔运算（双左、双右）{
返回lhs==rhs；
}
@凌驾
公共字符串toString（）{
返回“=”；
}
};
公共静态void main（字符串[]args）{
双x=3.14；
列表约束=新建ArrayList（）；
添加（新的一对（等于5.0））；
添加（新的一对（等于3.14））；
对于（成对约束：约束）{
运算符=constraint.left；
双值=constraint.right；
布尔结果=运算符。计算（x，值）；
System.out.println（x+运算符.toString（）+值+“=”+结果）；
}
}
}
我不太了解您的设置，但假设只有三个运算符（
，
），如果所有边界都是整数，则可以将每个条件转换为闭合范围。例如：


=x
是
[x，x]
是
[Integer.MIN\u值，x-1]

>x
是
[x+1，整数。最大值]

等等

您可以为每个输入条件构建其中一个范围，然后通过计算下限的最大值和下限的最小值来获取这些范围的交点

如果下限
的最大值是约束字符串参数？”==4“，"@JamesWierzba事实上，它们是
对的实例，其中enum可以等于、小于、大于……你明白了。这些条件看起来有什么限制吗？从你的示例中，我假设它们可能只在
int
域中运行，并且只有
==
、
和
运算符；这正确吗？如果您可以使用番石榴的范围，您可以为每个条件创建一个
范围
（例如
Range.singleton（4）
，
Range.upTo（5）
等），并且只需继续取范围的交点，直到得到一个空范围为止（或不）。或者，如果它们都是整数边界，则可以很容易地在没有范围的情况下执行：
==4
是范围
[4,4]
；
<5
是范围
[integer.MIN\u VALUE，4]
等等。只需取下界的最大值，上界的最小值，看看
min这是否在某种程度上重新发明了轮子。你可以用a作为接口。@James\u D我不同意，自己做这个会更有教育意义。此外，这比使用谓词扩展得多。此外
BiPredicate
是Java8。
  | > | < | ==
--+---+---+---
> |   | B | A 
--+---+---+---
< | B |   | C 
--+---+---+---
==| A | C |   

possibleA(int biggerThan, int equalTo) {
    return equalTo > biggerThan;
}

boolean canBeSatisfied(Iterable<Pair<enum, Integer>> conditions) {
  int maxLower = Integer.MAX_VALUE;
  int minUpper = Integer.MIN_VALUE;
  for (Pair<enum, Integer> condition : conditions) {
    maxLower = Math.max(maxLower, getLowerBound(condition));
    minUpper = Math.min(minUpper, getUpperBound(condition));
  }
  return maxLower <= minUpper;
}

int getLowerBound(Pair<enum, Integer> condition) {
  switch (condition.first) {
  case EQUALS:
  case GE:
    return condition.second;
  case GT:
    return condition.second + 1;
  case LT: case LE:
    return Integer.MIN_VALUE;
  }
}

int getUpperBound(Pair<enum, Integer> condition) {
  switch (condition.first) {
  case EQUALS:
  case GE: case GT:
    return Integer.MAX_VALUE;
  case LT:
    return condition.second - 1;
  case LE:
    return condition.second;
  }
}