Predicate的使用:

Predicate 是 Java 8 函数式接口 ，核心作用：接收一个参数，判断条件是否成立，返回布尔值（true/false） 。

简单理解：它就是一个 "判断器 / 过滤器"，你给它一个东西，它返回 true 或 false → 有入参，返回 boolean。

一、核心定义

java

运行

@FunctionalInterface
public interface Predicate<T> {
    // 唯一抽象方法：接收参数，返回 boolean
    boolean test(T t);
}

• T：输入（参数）的类型
• 核心方法：boolean test(T t)
• 专门做：条件判断、过滤、校验

二、最基础用法（必看）

1. 匿名内部类（老式）

java

运行

import java.util.function.Predicate;

public class PredicateTest {
    public static void main(String[] args) {
        // 判断：字符串长度是否大于 5
        Predicate<String> predicate = new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.length() > 5;
            }
        };

        // 调用 test() 方法判断
        boolean result1 = predicate.test("Hello"); // false
        boolean result2 = predicate.test("HelloWorld"); // true
        
        System.out.println(result1);
        System.out.println(result2);
    }
}

2. Lambda 简化（推荐）

java

运行

public class PredicateTest {
    public static void main(String[] args) {
        // Lambda 一行：判断数字是否大于 10
        Predicate<Integer> isGreaterThan10 = num -> num > 10;
        
        System.out.println(isGreaterThan10.test(5));  // false
        System.out.println(isGreaterThan10.test(20)); // true
    }
}

三、最常用场景：集合过滤（开发必备）

Java Stream.filter() 方法的参数就是 Predicate！这是你用得最多的地方。

java

运行

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

public class PredicateTest {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 5, 8, 12, 15, 20);

        // filter(Predicate)：过滤出 > 10 的数字
        List<Integer> result = list.stream()
                .filter(num -> num > 10) // 这里就是 Predicate
                .collect(Collectors.toList());

        System.out.println(result); // [12, 15, 20]
    }
}

四、高级用法：三大逻辑运算（and /or/negate）

Predicate 自带 3 个默认方法，实现复杂条件组合：

1. and：与（两个条件都满足）
2. or：或（满足一个即可）
3. negate：非（取反）

代码示例

java

运行

public class PredicateTest {
    public static void main(String[] args) {
        // 条件1：数字 > 5
        Predicate<Integer> p1 = num -> num > 5;
        // 条件2：数字 < 15
        Predicate<Integer> p2 = num -> num < 15;

        // 1. and：5 < num < 15
        boolean andResult = p1.and(p2).test(10); // true
        System.out.println("and: " + andResult);

        // 2. or：>5 或 <15
        boolean orResult = p1.or(p2).test(3); // true
        System.out.println("or: " + orResult);

        // 3. negate：取反（不大于5）
        boolean negateResult = p1.negate().test(3); // true
        System.out.println("negate: " + negateResult);
    }
}

五、实战：判断对象（开发常用）

判断用户是否满足条件（如：成年、姓名长度等）。

1. 实体类

java

运行

class User {
    private String name;
    private int age;

    // 构造、getter
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public int getAge() { return age; }
    public String getName() { return name; }
}

2. 使用 Predicate 判断

java

运行

public class PredicateTest {
    public static void main(String[] args) {
        User user = new User("张三", 20);

        // 判断：是否成年（age >= 18）
        Predicate<User> isAdult = u -> u.getAge() >= 18;
        System.out.println("是否成年：" + isAdult.test(user)); // true

        // 组合判断：成年 且 姓名长度 > 2
        Predicate<User> nameLength = u -> u.getName().length() > 2;
        boolean complex = isAdult.and(nameLength).test(user);
        System.out.println("复合条件：" + complex); // true
    }
}

六、封装通用校验工具

把 Predicate 当作参数，实现通用条件校验。

java

运行

public class PredicateTest {
    // 通用工具：传入数据 + 判断规则，返回判断结果
    public static <T> boolean validate(T data, Predicate<T> predicate) {
        System.out.println("开始校验数据...");
        return predicate.test(data);
    }

    public static void main(String[] args) {
        // 校验字符串是否为空
        boolean b1 = validate("Hello", s -> !s.isEmpty());
        System.out.println(b1); // true

        // 校验年龄是否合法
        boolean b2 = validate(new User("李四", 15), u -> u.getAge() >= 18);
        System.out.println(b2); // false
    }
}

七、扩展：BiPredicate（两个参数判断）

如果需要接收两个参数 进行判断，用 BiPredicate<T, U>：

java

运行

import java.util.function.BiPredicate;

public class PredicateTest {
    public static void main(String[] args) {
        // 判断：两个数字是否相等
        BiPredicate<Integer, Integer> isEqual = (a, b) -> a.equals(b);
        
        System.out.println(isEqual.test(10, 10)); // true
        System.out.println(isEqual.test(5, 8));   // false
    }
}

八、四大函数式接口终极对比（必记）

表格

接口	入参	返回值	一句话理解	核心用途
Supplier	无	有	工厂，生产数据	创建对象、懒加载
Function	1 个	有	转换器，加工数据	类型转换、提取属性
Consumer	1 个	无	消费者，处理数据	打印、修改属性
Predicate	1 个	boolean	判断器，条件过滤	筛选、校验、判断

---

九、核心总结

1. Predicate<T>：接收参数，返回 boolean
2. 核心方法：test(T t)
3. 核心能力：条件判断、集合过滤、逻辑组合（and/or/negate）
4. 最常用场景：Stream.filter () 过滤数据
5. 作为方法参数：代码更灵活、通用、可复用

一句话记住：需要做条件判断、过滤筛选，就用 Predicate！