Java中函数的高级玩法之Predicate接口

函数接口之Predicate

Predicate 是 Java 8 引入的一个函数式接口，位于 java.util.function 包中。它代表了一个布尔值的函数，用于判断某个条件是否满足。Predicate 接口的主要方法是 test，该方法接受一个输入参数并返回一个布尔值。

主要方法

1. boolean test(T t) ：判断给定的输入是否满足条件，返回 true 或 false。
2. default Predicate and(Predicate<? super T> other)： ：组合两个 Predicate，只有当两个 Predicate 都返回 true 时，结果才为 true。
3. default Predicate or(Predicate<? super T> other)： ：组合两个 Predicate，只要其中一个 Predicate 返回 true，结果就为 true。
4. default Predicate negate() ：返回当前 Predicate 的否定形式。

示例代码

以下是一些使用 Predicate 的示例：

Predicate的简单用法

import java.util.function.Predicate;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class PredicateExample {
    public static void main(String[] args) {
        // 定义一个 Predicate，判断字符串长度是否大于 5
        Predicate<String> isLongString = s -> s.length() > 5;

        // 测试 Predicate
        System.out.println(isLongString.test("Hello")); // 输出: false
        System.out.println(isLongString.test("HelloWorld")); // 输出: true

        // 组合 Predicate
        Predicate<String> startsWithH = s -> s.startsWith("H");
        Predicate<String> combinedPredicate = isLongString.and(startsWithH);

        System.out.println(combinedPredicate.test("Hello")); // 输出: false
        System.out.println(combinedPredicate.test("HelloWorld")); // 输出: true

        // 使用 Predicate 进行过滤
        List<String> words = Arrays.asList("Hello", "World", "Java", "Stream", "Lambda");
        List<String> filteredWords = words.stream()
                                          .filter(isLongString)
                                          .collect(Collectors.toList());

        System.out.println(filteredWords); // 输出: [HelloWorld, Stream, Lambda]
    }
}

组合 Predicate：使用 and 和 or

import java.util.function.Predicate;

public class PredicateExample2 {
    public static void main(String[] args) {
        // 定义多个 Predicate
        Predicate<String> isLongString = s -> s.length() > 5;
        Predicate<String> startsWithH = s -> s.startsWith("H");

        // 使用 and 组合 Predicate
        Predicate<String> combinedPredicateAnd = isLongString.and(startsWithH);
        System.out.println(combinedPredicateAnd.test("Hello")); // 输出: false
        System.out.println(combinedPredicateAnd.test("HelloWorld")); // 输出: true

        // 使用 or 组合 Predicate
        Predicate<String> combinedPredicateOr = isLongString.or(startsWithH);
        System.out.println(combinedPredicateOr.test("Hi")); // 输出: false
        System.out.println(combinedPredicateOr.test("Hello")); // 输出: true
        System.out.println(combinedPredicateOr.test("World")); // 输出: false
        System.out.println(combinedPredicateOr.test("HelloWorld")); // 输出: true
    }
}

复杂条件组合：多层嵌套 Predicate

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.function.Predicate;

public class PredicateExample5 {
    public static void main(String[] args) {
        // 创建一个字符串列表
        List<String> words = Arrays.asList("Hello", "World", "Java", "Stream", "Lambda", "Programming");

        // 定义多个 Predicate
        Predicate<String> isLongString = s -> s.length() > 5;
        Predicate<String> startsWithH = s -> s.startsWith("H");
        Predicate<String> endsWithg = s -> s.endsWith("g");

        // 多层嵌套 Predicate
        Predicate<String> complexPredicate = isLongString.and(startsWithH.or(endsWithg));

        // 使用复杂 Predicate 进行过滤
        List<String> filteredWords = words.stream()
                                          .filter(complexPredicate)
                                          .collect(Collectors.toList());

        // 输出过滤后的结果
        System.out.println(filteredWords); // 输出: [Hello, Programming]
    }
}