java-8 - 用于比较谓词的链式 java.util.function.Predicate 调用

Question

我正在努力让它工作:

Predicate<Integer> predicateInteger = i ->  i>0;
System.out.println(predicateInteger.test(1)); // works and prints true

现在我尝试使用 equals 定义另一个谓词，例如 predicateInteger :

// stmt below DOES NOT COMPILE : Target type of a lambda conversion must be an interface

Predicate<Integer> predicateEq = predicateInteger.equals(i -> new Boolean(true));
System.out.println(predicateEq.test(8));// I want this to print "TRUE" on equals .

我在这里做错了什么？

Answer 1

这不是谓词和函数式接口(interface)(lambda 表达式)的一般情况。 Predicate类有唯一的方法boolean test(T t) 。 lambda 表达式与匿名类实现没有什么不同。请注意，没有equals方法，因此 lambda 表达式不具有可比性(就相等性而言)。

Predicate<Integer> predicateInteger = i -> i > 0;

Predicate<Integer> predicateInteger = new Predicate<Integer>() {
    @Override
    public boolean test(Integer i) {
        return i > 0;
    }
}

实际上，Predicate#test返回boolean可以直接打印出来:

Predicate<Integer> integerPredicate = i -> i > 0;
System.out.println(integerPredicate.test(8));                                  // true

似乎您想要将结果值与其他 Predicate 定义的值进行比较。 .

Predicate<Integer> integerPredicate = i -> i > 0;
Predicate<Object> resultPredicate = i -> true;

boolean result = integerPredicate.test(8) == resultPredicate.test("whatever");
System.out.println(result);                                                    // true

请注意，事实上，Predicate<Object> predicate = i -> true实际上是 Supplier无论输入如何，它都会返回一个常量值(实际上，它没有输入)。

Predicate<Integer> integerPredicate = i -> i > 0;
Supplier<Boolean> resultSupplier = () -> true;

boolean result = integerPredicate.test(8) == resultSupplier.get();
System.out.println(result);                                                    // true

但是，只要 integerPredicate 就没有任何意义可以直接打印出来没有resultSupplier .

Predicate<Integer> integerPredicate = i -> i > 0;
System.out.println(integerPredicate.test(8));                                  // true

...我们又回到了起点。

---

我想到的最后一件事是始终在方法 test 上打印结果称呼。您所需要的只是定义一个装饰器，它包装 Predicate委托(delegate)并提交对 test 的操作使用 Consumer<Boolean 调用方法哪里Boolean是前一个谓词的结果。

@AllArgsConstructor // constructor omitted (Lombok) for sake of brevity
public class CallbackPredicate<T> implements Predicate<T> {

    private final Predicate<T> delegate;
    private final Consumer<Boolean> callback;

    @Override
    public final boolean test(final T t) {
        boolean result = delegate.test(t);
        callback.accept(result);
        return result;
    }
}

Predicate<Integer> integerPredicate = new CallbackPredicate<>(
        i -> i > 0,                                              // Predicate<Integer>
        System.out::println);                                    // Callback

integerPredicate.test(8);                                        // prints true

---

谓词也可以使用 AND 进行链接由 Predicate#and 表示的子句方法:

Predicate<Integer> largerThanZero = i -> i > 0;
Predicate<Integer> smallerThanSix = i -> i < 6;

Predicate<Integer> betweenZeroAndSix = largerThanZero.and(smallerThanSix);

System.out.println(betweenZeroAndSix.test(-5));                  // false
System.out.println(betweenZeroAndSix.test(5));                   // true
System.out.println(betweenZeroAndSix.test(15));                  // false