java - 用真值表过滤

想象一个带有布尔标志的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 ^(＃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(ofWorkingAge && ofGoodCharacter && isQualified){
    c1++;
    p.setEmployable(true)
}
else if(ofWorkingAge && ofGoodCharacter && !isQualified){
    c2++;
    p.setEmployable(true)
}
...
else if(!ofWorkingAge && !ofGoodCharacter && isQualified){
    c7++;
}
else{
    c8++;
}

真不好

更智能的解决方案

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

我可以看到如何使用功能接口来完成操作。 This SO answer可能相关。您可以将PrintCommand更改为IsQualified，并将callCommand传递给Person而不是字符串。但这似乎还有些笨拙，因为我们必须为每个提出的谓词都拥有一个新的接口文件。

还有其他Java 8类方法吗？

最佳答案

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

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");

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

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