6

想象一个带有布尔标志的 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，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++;
}

这很糟糕。

更智能的解决方案

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

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

有没有其他 Java 8-ish 方法可以做到这一点？

4

3 回答 3

3

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

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

现在我们需要生成一个真值表，它是一个新的谓词列表，其名称为 like"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));
于 2015-11-05T08:57:19.910 回答
2
于 2015-11-05T10:11:22.963 回答
0

我不确定这是否是您要查找的内容，但是您可以在变量上使用按位运算符..

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

其中最后一位代表工作年龄/良好字符/合格。

于 2015-11-05T05:37:54.420 回答