预定义的函数式接口 Predicate

函数接口: Predicate<T>

方法定义: boolean test(T t);

说明: 测试输入是否满足条件

接口源码

@FunctionalInterface
public interface Predicate<T> {
    /**
     * 具体过滤操作 需要被子类实现.
     * 用来处理参数T是否满足要求,可以理解为 条件A
     */
    boolean test(T t);
    /**
     * 调用当前Predicate的test方法之后再去调用other的test方法,相当于进行两次判断
     * 可理解为 条件A && 条件B
     */
    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }
    /**
     * 对当前判断进行"!"操作,即取非操作，可理解为 !条件A
     */
    default Predicate<T> negate() {
        return (t) -> !test(t);
    }
    /**
     * 对当前判断进行"||"操作,即取或操作,可以理解为 条件A ||条件B
     */
    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

    /**
     * 对当前操作进行"="操作,即取等操作,可以理解为 A == B
     */
    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

Predicate示例

定义一个学生类Student，它有name和score两个属性，如下所示。

@Setter
@Getter
public class Student {

    String name;

    double score;

    public Student(String name, double score) {
        this.name = name;
        this.score = score;
    }
}

在日常开发中，列表处理的一个常见需求是过滤，列表的类型经常不一样，过滤的条件也经常变化，但主体逻辑都是类似的，可以借助Predicate写一个通用的方法，如下所示：

    public static <E> List<E> filter(List<E> list, Predicate<E> pred) {
        List<E> retList = new ArrayList<>();
        for (E e : list) {
            if (pred.test(e)) {
                retList.add(e);
            }
        }
        return retList;
    }

这个方法可以这么用：

        List<Student> students = Arrays.asList(new Student[]{
                new Student("zhangsan", 80d),
                new Student("lisi", 89d),
                new Student("wangwu", 98d)});

        Predicate<Student> predicate = t -> t.getScore() > 80;//过滤 >80
        List<Student> students_1 = filter(students, predicate);
        System.out.println("students_1:" + students_1.toString());

        Predicate<Student> predicate_and = predicate.and(t -> t.getScore() < 90);//过滤 <90
        List<Student> students_2 = filter(students, predicate_and);
        System.out.println("students_2:" + students_2.toString());