想象一个带有 boolean 标志的 Person 类，该标志指示此人是否可雇用 - 默认设置为 false。

public class Person{
    boolean employable = false;
    ...
}

现在想象一下有一些作用于 Person 对象的外部 boolean 方法。例如，考虑实用程序类中的静态 boolean 方法。

public class PersonUtil{
    public static boolean ofWorkingAge(Person p){
        if(p.getAge() > 16) return true;
        return false;
    }
    ...
}

boolean 静态方法本质上类似于 boolean 值函数，即谓词。

我们可以用谓词构建一个 2^(#predicates)-by-#predicates 真值表。例如，给定三个谓词:ofWorkingAge、ofGoodCharacter、isQualified，我们可以构建以下 8×3 真值表:

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 对象的集合。对于每个人，我们根据三个谓词调整他们的就业能力标志。 我们还更新了一个计数(这迫使我们使用整个真值表而不仅仅是正值)，因此给定 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

大概这可以被认为是用真值表过滤。设置就业能力标志和更新计数是一个相当人为的示例，但您可以很容易地看出我们可能希望如何设置和更新更复杂的事情。

问题

有没有办法优雅地做到这一点？我可以想到两种解决方案:

笨拙的解决方案

用巨手编写 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++;
}

这很糟糕。

稍微聪明一点的解决方案

将谓词(可能在数组中)和一组句子传递给方法。让方法生成相应的真值表。遍历人员，设置他们的就业能力，并返回一组计数。

我可以看到如何使用功能接口(interface)来完成事情。 This SO answer是潜在相关的。您可以将 PrintCommand 更改为 IsQualified 并向 callCommand 传递一个 Person 而不是字符串。但这也看起来有点笨拙，因为我们必须为我们提出的每个谓词创建一个新的接口(interface)文件。

是否有任何其他 Java 8-ish 方法可以做到这一点？

最佳答案

让我们从您拥有的谓词列表开始:

List<Predicate<Person>> predicates = Arrays.<Predicate<Person>> asList(
        PersonUtil::ofWorkingAge, PersonUtil::ofGoodCharacter,
        PersonUtil::isQualified);

为了跟踪哪个谓词是真还是假，让我们为它们附加名称创建NamedPredicate类:

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 名称也可以)。

现在我们需要生成一个真值表，它是一个新的谓词列表，其名称类似于 "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

现在您可以对 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我们需要知道如何指定所需真值表的字段。让它成为这样的真值字符串的集合:

Collection<String> desired = Arrays.asList("T T T", "T T F", "T F T", "F T T");

在这种情况下，您可以使用之前生成的 map :

desired.stream()
       .flatMap(k -> map.get(k).stream())
       .forEach(person -> person.setEmployable(true));

关于java - 用真值表过滤，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/33537307/