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

我正在努力让它工作：

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

---

我在这里做错了什么？

这不是谓词和函数接口（lambda表达式）通常的用法。

谓词

类具有唯一的方法

布尔测试（T）

。lambda表达式与匿名类实现没有什么不同。请注意，有no

equals

方法，因此lambda表达式是不可比较的（在相等方面）

似乎要将结果值与其他值进行比较，这些值由另一个

谓词定义

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

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

但是，只要不使用
resultSupplier
就可以直接打印出
integerPredicate
，这是没有意义的

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

这帮助我实现了我想要的：

// when this is the first predicate:
Predicate<Integer> predicateInteger = i ->  i>0;  
// and when this second predicate compares with the first, 
Predicate<Integer> predicateEq = predicateInteger.and(i -> i<6); 
// then :
System.out.println(predicateEq.test(5));// prints true

//当这是第一个谓词时：
谓词谓词Integer=i->i>0；
//当第二个谓词与第一个谓词比较时，
Predicate predicateEq=predicateInteger.and（i->iI很难理解您的需求。
i>0
本身就是一个谓词，当
test
ed时会返回
true
或
false
。即使java允许您继续第二条语句，它仍然没有任何意义，因为
if（something.equals（true））
与if（something）
相同。这个问题没有任何意义。你没有链接谓词，“在equals上打印”true“是不可理解的。在调用
test
的语句上下文中，“在equals上”是什么意思？它为什么要打印字符串
true
当这段代码中没有任何内容引用该字符串时？感谢分享这一精彩的解释。这真的很有帮助！。然而，我试图比较两个谓词的结果，这是否也是正确的方法：`Predicate-predicateInteger=I->I>0；`->这是第一个谓词，然后：Predicate-predicateEq=predicateInteg和（我->我是第二个谓词，`System.out.println（predicateEq.test（5））；`//prints trueCheck我的编辑。我想你有足够的材料来了解谓词（和其他函数接口）是如何工作的。回答得好@nikolasharalalambidis；）
Predicate<Integer> integerPredicate = i -> i > 0;
System.out.println(integerPredicate.test(8));                                  // true

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<Integer> integerPredicate = i -> i > 0;
Supplier<Boolean> resultSupplier = () -> true;

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

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

@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

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

// when this is the first predicate:
Predicate<Integer> predicateInteger = i ->  i>0;  
// and when this second predicate compares with the first, 
Predicate<Integer> predicateEq = predicateInteger.and(i -> i<6); 
// then :
System.out.println(predicateEq.test(5));// prints true