用真值表过滤
Filtering with truth tables
假设一个人 class 带有一个布尔标志，指示此人是否可以就业 - 默认设置为 false。
public class Person{
boolean employable = false;
...
}
现在想象一下有一些 external 布尔方法作用于 Person 对象。例如，考虑实用程序 class.
中的静态布尔方法
public class PersonUtil{
public static boolean ofWorkingAge(Person p){
if(p.getAge() > 16) return true;
return false;
}
...
}
布尔静态方法本质上类似于布尔值函数，即谓词。
我们可以用谓词构造一个 2^(#predicates)-by-#predicates 真值 table。例如，给定三个谓词：ofWorkingAge、ofGoodCharacter、isQualified 我们可以构造以下 8-by -3 真相 table:
T T T
T T F
T F T
T F F
F T T
F T F
F F T
F F F
我们现在想雇用具有理想品质的人。让 + 表示我们希望考虑某人的就业能力（即将他们的就业能力标志设置为 true）和 - 反之
T T T | +
T T F | +
T F T | +
T F F | -
F T T | +
F T F | -
F F T | -
F F F | -
现在想象一下有一个 Person 对象的集合。对于每个人，我们根据三个谓词调整他们的就业能力标志。 我们还更新了一个计数（这迫使我们使用全部真相 table 而不仅仅是正面），因此给定 1,000 个人，我们希望得到如下结果：
T T T | + 100
T T F | + 200
T F T | + 50
T F F | - 450
F T T | + 50
F T F | - 50
F F T | - 50
F F F | - 50
大概这可以被认为是过滤真值 tables。设置就业能力标志和更新计数是一个相当人为的示例，但您可以很容易地看出我们可能希望如何设置和更新更复杂的事情。
问题
有没有办法优雅地做到这一点？我可以想到两个解决方案：
笨拙的解决方案
有一只巨手编码 if, else if, else 链。
if(ofWorkingAge && ofGoodCharacter && isQualified){
c1++;
p.setEmployable(true)
}
else if(ofWorkingAge && ofGoodCharacter && !isQualified){
c2++;
p.setEmployable(true)
}
...
else if(!ofWorkingAge && !ofGoodCharacter && isQualified){
c7++;
}
else{
c8++;
}
这太糟糕了。
稍微聪明一点的解决方案
将谓词（可能在数组中）和句子集合传递给方法。让方法生成相应的真值table。遍历人员，设置他们的就业能力，以及 return 一组计数。
我可以看到如何使用功能接口来完成事情。 This SO answer 可能相关。您可以将 PrintCommand 更改为 IsQualified 并向 callCommand 传递一个 Person 而不是字符串。但这也看起来有点笨拙，因为我们必须为我们提出的每个谓词创建一个新的接口文件。
还有其他 Java 8 种方法可以做到这一点吗？
我不确定这是否是您要查找的内容，但您可以对变量使用按位运算符..
if(ofWorkingAge && ofGoodCharacter && isQualified){
c1++;
p.setEmployable(true)
}
可能会变成
int combined = 0b00000000;
combined |= ofWorkingAge ? 0b00000100 : 0b00000000;
combined |= ofGoodCharacter ? 0b00000010 : 0b00000000;
combined |= isQualified ? 0b00000001 : 0b00000000;
switch (combined){
case 0b00000111:
c1++;
p.setEmployable(true)
break;
case 0b00000110:
// etc
其中最后一位代表 ofWorkingAge/ofGoodCharacter/isQualified。
让我们从您拥有的谓词列表开始：
List<Predicate<Person>> predicates = Arrays.<Predicate<Person>> asList(
PersonUtil::ofWorkingAge, PersonUtil::ofGoodCharacter,
PersonUtil::isQualified);
为了跟踪哪个谓词是真还是假，让我们为它们附加名称创建 NamedPredicate class:
public static class NamedPredicate<T> implements Predicate<T> {
final Predicate<T> predicate;
final String name;
public NamedPredicate(Predicate<T> predicate, String name) {
this.predicate = predicate;
this.name = name;
}
@Override
public String toString() {
return name;
}
@Override
public boolean test(T t) {
return predicate.test(t);
}
}
（可以附上 BitSet 或类似的东西以提高效率，但 String 名称也可以）。
现在我们需要生成一个真值 table，它是一个新的谓词列表，其名称类似于 "T T F"，并且能够应用给定的源谓词组合，无论是否否定。这可以通过一些函数式编程魔法轻松生成：
Supplier<Stream<NamedPredicate<Person>>> truthTable
= predicates.stream() // start with plain predicates
.<Supplier<Stream<NamedPredicate<Person>>>>map(
// generate a supplier which creates a stream of
// true-predicate and false-predicate
p -> () -> Stream.of(
new NamedPredicate<>(p, "T"),
new NamedPredicate<>(p.negate(), "F")))
.reduce(
// reduce each pair of suppliers to the single supplier
// which produces a Cartesian product stream
(s1, s2) -> () -> s1.get().flatMap(np1 -> s2.get()
.map(np2 -> new NamedPredicate<>(np1.and(np2), np1+" "+np2))))
// no input predicates? Fine, produce empty stream then
.orElse(Stream::empty);
因为 truthTable 是一个 Supplier<Stream>，您可以根据需要多次重复使用它。另请注意，所有 NamedPredicate 对象都是按需动态生成的，我们不会将它们存储在任何地方。让我们尝试使用这个供应商：
truthTable.get().forEach(System.out::println);
输出为：
T T T
T T F
T F T
T F F
F T T
F T F
F F T
F F F
现在你可以class通过真相table验证persons集合，例如，通过以下方式：
Map<String,List<Person>> map = truthTable.get().collect(
Collectors.toMap(np -> np.toString(), // Key is string like "T T F"
// Value is the list of persons for which given combination is true
np -> persons.stream().filter(np).collect(Collectors.toList()),
// Merge function: actually should never happen;
// you may throw assertion error here instead
(a, b) -> a,
// Use LinkedHashMap to preserve an order
LinkedHashMap::new));
现在您可以轻松获得计数：
map.forEach((k, v) -> System.out.println(k+" | "+v.size()));
要更新 employable 字段，我们需要知道如何指定所需的真值 table。让它成为这样的真值字符串的集合：
Collection<String> desired = Arrays.asList("T T T", "T T F", "T F T", "F T T");
在这种情况下，您可以使用之前生成的地图：
desired.stream()
.flatMap(k -> map.get(k).stream())
.forEach(person -> person.setEmployable(true));
基本上，真值是一个位，您总是可以使用 n 位的整数值来编码 n 真值.然后，将整数值解释为数字允许您使用线性 table.
将值与真值组合相关联
因此，使用 int 编码真值/ table 索引，一般真值 table class 可能如下所示：
public class TruthTable<O,V> {
final List<? extends Predicate<? super O>> predicates;
final ArrayList<V> values;
@SafeVarargs
public TruthTable(Predicate<? super O>... predicates) {
int size=predicates.length;
if(size==0 || size>31) throw new UnsupportedOperationException();
this.predicates=Arrays.stream(predicates)
.map(Objects::requireNonNull).collect(Collectors.toList());
values=new ArrayList<>(Collections.nCopies(1<<size, null));
}
public V get(O testable) {
return values.get(index(testable, predicates));
}
public V get(boolean... constant) {
if(constant.length!=predicates.size())
throw new IllegalArgumentException();
return values.get(index(constant));
}
public V set(V value, boolean... constant) {
if(constant.length!=predicates.size())
throw new IllegalArgumentException();
return values.set(index(constant), value);
}
public static <T> int index(T object, List<? extends Predicate<? super T>> p) {
int size=p.size();
if(size==0 || size>31) throw new UnsupportedOperationException();
return IntStream.range(0, size).map(i->p.get(i).test(object)? 1<<i: 0)
.reduce((a,b) -> a|b).getAsInt();
}
public static <T> int index(boolean... values) {
int size=values.length;
if(size==0 || size>31) throw new UnsupportedOperationException();
return IntStream.range(0, size).map(i->values[i]? 1<<i: 0)
.reduce((a,b) -> a|b).getAsInt();
}
}
重点是根据真值计算int索引。有两个版本。首先，根据用于初始化 table 或查询其状态的显式布尔值进行计算，其次，针对实际测试对象和适用谓词列表进行计算。请注意，这两种方法已分解为 public static 方法，因此它们可用于替代 table 类型，例如一组原始值。唯一要做的就是在有 n 谓词时为 2ⁿ 值创建线性存储，例如new int[1<<n] 然后使用这些 index 方法来确定要访问给定值或实际测试候选人的条目。
泛型 TruthTable 的实例可以按如下方式使用：
TruthTable<Person,Integer> scoreTable=new TruthTable<>(
PersonUtil::ofWorkingAge, PersonUtil::ofGoodCharacter, PersonUtil::isQualified);
scoreTable.set(+100, true, true, true);
scoreTable.set(+200, true, true, false);
scoreTable.set(+50, true, false, true);
scoreTable.set(-450, true, false, false);
scoreTable.set(+50, false, true, true);
scoreTable.set(-50, false, true, false);
scoreTable.set(-50, false, false, true);
scoreTable.set(-50, false, false, false);
Person p = …
int score = scoreTable.get(p);
假设一个人 class 带有一个布尔标志，指示此人是否可以就业 - 默认设置为 false。
public class Person{
boolean employable = false;
...
}
现在想象一下有一些 external 布尔方法作用于 Person 对象。例如，考虑实用程序 class.
中的静态布尔方法public class PersonUtil{
public static boolean ofWorkingAge(Person p){
if(p.getAge() > 16) return true;
return false;
}
...
}
布尔静态方法本质上类似于布尔值函数，即谓词。
我们可以用谓词构造一个 2^(#predicates)-by-#predicates 真值 table。例如，给定三个谓词：ofWorkingAge、ofGoodCharacter、isQualified 我们可以构造以下 8-by -3 真相 table:
T T T
T T F
T F T
T F F
F T T
F T F
F F T
F F F
我们现在想雇用具有理想品质的人。让 + 表示我们希望考虑某人的就业能力（即将他们的就业能力标志设置为 true）和 - 反之
T T T | +
T T F | +
T F T | +
T F F | -
F T T | +
F T F | -
F F T | -
F F F | -
现在想象一下有一个 Person 对象的集合。对于每个人，我们根据三个谓词调整他们的就业能力标志。 我们还更新了一个计数（这迫使我们使用全部真相 table 而不仅仅是正面），因此给定 1,000 个人，我们希望得到如下结果：
T T T | + 100
T T F | + 200
T F T | + 50
T F F | - 450
F T T | + 50
F T F | - 50
F F T | - 50
F F F | - 50
大概这可以被认为是过滤真值 tables。设置就业能力标志和更新计数是一个相当人为的示例，但您可以很容易地看出我们可能希望如何设置和更新更复杂的事情。
问题
有没有办法优雅地做到这一点？我可以想到两个解决方案：
笨拙的解决方案
有一只巨手编码 if, else if, else 链。
if(ofWorkingAge && ofGoodCharacter && isQualified){
c1++;
p.setEmployable(true)
}
else if(ofWorkingAge && ofGoodCharacter && !isQualified){
c2++;
p.setEmployable(true)
}
...
else if(!ofWorkingAge && !ofGoodCharacter && isQualified){
c7++;
}
else{
c8++;
}
这太糟糕了。
稍微聪明一点的解决方案
将谓词（可能在数组中）和句子集合传递给方法。让方法生成相应的真值table。遍历人员，设置他们的就业能力，以及 return 一组计数。
我可以看到如何使用功能接口来完成事情。 This SO answer 可能相关。您可以将 PrintCommand 更改为 IsQualified 并向 callCommand 传递一个 Person 而不是字符串。但这也看起来有点笨拙，因为我们必须为我们提出的每个谓词创建一个新的接口文件。
还有其他 Java 8 种方法可以做到这一点吗？
我不确定这是否是您要查找的内容，但您可以对变量使用按位运算符..
if(ofWorkingAge && ofGoodCharacter && isQualified){
c1++;
p.setEmployable(true)
}
可能会变成
int combined = 0b00000000;
combined |= ofWorkingAge ? 0b00000100 : 0b00000000;
combined |= ofGoodCharacter ? 0b00000010 : 0b00000000;
combined |= isQualified ? 0b00000001 : 0b00000000;
switch (combined){
case 0b00000111:
c1++;
p.setEmployable(true)
break;
case 0b00000110:
// etc
其中最后一位代表 ofWorkingAge/ofGoodCharacter/isQualified。
让我们从您拥有的谓词列表开始：
List<Predicate<Person>> predicates = Arrays.<Predicate<Person>> asList(
PersonUtil::ofWorkingAge, PersonUtil::ofGoodCharacter,
PersonUtil::isQualified);
为了跟踪哪个谓词是真还是假，让我们为它们附加名称创建 NamedPredicate class:
public static class NamedPredicate<T> implements Predicate<T> {
final Predicate<T> predicate;
final String name;
public NamedPredicate(Predicate<T> predicate, String name) {
this.predicate = predicate;
this.name = name;
}
@Override
public String toString() {
return name;
}
@Override
public boolean test(T t) {
return predicate.test(t);
}
}
（可以附上 BitSet 或类似的东西以提高效率，但 String 名称也可以）。
现在我们需要生成一个真值 table，它是一个新的谓词列表，其名称类似于 "T T F"，并且能够应用给定的源谓词组合，无论是否否定。这可以通过一些函数式编程魔法轻松生成：
Supplier<Stream<NamedPredicate<Person>>> truthTable
= predicates.stream() // start with plain predicates
.<Supplier<Stream<NamedPredicate<Person>>>>map(
// generate a supplier which creates a stream of
// true-predicate and false-predicate
p -> () -> Stream.of(
new NamedPredicate<>(p, "T"),
new NamedPredicate<>(p.negate(), "F")))
.reduce(
// reduce each pair of suppliers to the single supplier
// which produces a Cartesian product stream
(s1, s2) -> () -> s1.get().flatMap(np1 -> s2.get()
.map(np2 -> new NamedPredicate<>(np1.and(np2), np1+" "+np2))))
// no input predicates? Fine, produce empty stream then
.orElse(Stream::empty);
因为 truthTable 是一个 Supplier<Stream>，您可以根据需要多次重复使用它。另请注意，所有 NamedPredicate 对象都是按需动态生成的，我们不会将它们存储在任何地方。让我们尝试使用这个供应商：
truthTable.get().forEach(System.out::println);
输出为：
T T T
T T F
T F T
T F F
F T T
F T F
F F T
F F F
现在你可以class通过真相table验证persons集合，例如，通过以下方式：
Map<String,List<Person>> map = truthTable.get().collect(
Collectors.toMap(np -> np.toString(), // Key is string like "T T F"
// Value is the list of persons for which given combination is true
np -> persons.stream().filter(np).collect(Collectors.toList()),
// Merge function: actually should never happen;
// you may throw assertion error here instead
(a, b) -> a,
// Use LinkedHashMap to preserve an order
LinkedHashMap::new));
现在您可以轻松获得计数：
map.forEach((k, v) -> System.out.println(k+" | "+v.size()));
要更新 employable 字段，我们需要知道如何指定所需的真值 table。让它成为这样的真值字符串的集合：
Collection<String> desired = Arrays.asList("T T T", "T T F", "T F T", "F T T");
在这种情况下，您可以使用之前生成的地图：
desired.stream()
.flatMap(k -> map.get(k).stream())
.forEach(person -> person.setEmployable(true));
基本上，真值是一个位，您总是可以使用 n 位的整数值来编码 n 真值.然后，将整数值解释为数字允许您使用线性 table.
将值与真值组合相关联因此，使用 int 编码真值/ table 索引，一般真值 table class 可能如下所示：
public class TruthTable<O,V> {
final List<? extends Predicate<? super O>> predicates;
final ArrayList<V> values;
@SafeVarargs
public TruthTable(Predicate<? super O>... predicates) {
int size=predicates.length;
if(size==0 || size>31) throw new UnsupportedOperationException();
this.predicates=Arrays.stream(predicates)
.map(Objects::requireNonNull).collect(Collectors.toList());
values=new ArrayList<>(Collections.nCopies(1<<size, null));
}
public V get(O testable) {
return values.get(index(testable, predicates));
}
public V get(boolean... constant) {
if(constant.length!=predicates.size())
throw new IllegalArgumentException();
return values.get(index(constant));
}
public V set(V value, boolean... constant) {
if(constant.length!=predicates.size())
throw new IllegalArgumentException();
return values.set(index(constant), value);
}
public static <T> int index(T object, List<? extends Predicate<? super T>> p) {
int size=p.size();
if(size==0 || size>31) throw new UnsupportedOperationException();
return IntStream.range(0, size).map(i->p.get(i).test(object)? 1<<i: 0)
.reduce((a,b) -> a|b).getAsInt();
}
public static <T> int index(boolean... values) {
int size=values.length;
if(size==0 || size>31) throw new UnsupportedOperationException();
return IntStream.range(0, size).map(i->values[i]? 1<<i: 0)
.reduce((a,b) -> a|b).getAsInt();
}
}
重点是根据真值计算int索引。有两个版本。首先，根据用于初始化 table 或查询其状态的显式布尔值进行计算，其次，针对实际测试对象和适用谓词列表进行计算。请注意，这两种方法已分解为 public static 方法，因此它们可用于替代 table 类型，例如一组原始值。唯一要做的就是在有 n 谓词时为 2ⁿ 值创建线性存储，例如new int[1<<n] 然后使用这些 index 方法来确定要访问给定值或实际测试候选人的条目。
泛型 TruthTable 的实例可以按如下方式使用：
TruthTable<Person,Integer> scoreTable=new TruthTable<>(
PersonUtil::ofWorkingAge, PersonUtil::ofGoodCharacter, PersonUtil::isQualified);
scoreTable.set(+100, true, true, true);
scoreTable.set(+200, true, true, false);
scoreTable.set(+50, true, false, true);
scoreTable.set(-450, true, false, false);
scoreTable.set(+50, false, true, true);
scoreTable.set(-50, false, true, false);
scoreTable.set(-50, false, false, true);
scoreTable.set(-50, false, false, false);
Person p = …
int score = scoreTable.get(p);