使用真值表过滤

Question

想象一个带有布尔标志的Person类,该布尔标志指示该人是否可以使用 - 默认情况下设置为false.

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

现在假设有一些外部布尔方法作用于Person对象.例如,考虑实用程序类中的静态布尔方法.

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

布尔静态方法本质上类似于布尔值函数,即谓词.

我们可以用谓词构造一个2 ^(#谓词)-by-#谓词真值表.例如,给定三个谓词: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

我们现在想雇用具有理想品质的人.让+表示我们希望考虑某人可就业(即将他们的就业能力标志设为真)和-相反.

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对象的集合.对于每个人,我们根据三个谓词调整他们的就业能力标志.我们还更新了一个计数(这迫使我们使用整个真值表而不仅仅是积极因素),因此我们希望最终得到1000个人:

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(ofWorkingAge && ofGoodCharacter && isQualified){
    c1++;
    p.setEmployable(true)
}
else if(ofWorkingAge && ofGoodCharacter && !isQualified){
    c2++;
    p.setEmployable(true)
}
...
else if(!ofWorkingAge && !ofGoodCharacter && isQualified){
    c7++;
}
else{
    c8++;
}

这很糟糕.

更智能的解决方案

将谓词(可能在数组中)和句子集合传递给方法.让方法生成相应的真值表.循环人,设定他们的就业能力,并返回一系列计数.

我可以看到功能界面如何完成.这个SO答案可能具有相关性.你可以改变PrintCommand到IsQualified并通过callCommand一个人而不是一个字符串.但这似乎有点笨拙,因为我们必须为我们提出的每个谓词都有一个新的接口文件.

还有其他Java 8-ish方法吗？

Answer 1

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

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

要跟踪哪个谓词是 true 或 false，让我们为它们附加名称以创建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);

与truthTablea一样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");

在这种情况下，您可以使用之前生成的地图：

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