逐步走向响应式编程（一）-常见函数式接口- Predicate＜T＞

在了解函数式接口前，希望大家有一定的lamda表达式的基础，可以参考此博客。本文细说一下java8常见的函数式接口-Predicate，希望对大家有一定的帮助。

本接口用的比较多，称之为断言接口，用于条件判断，其中唯一需要实现的方法为test(T t)，其实现逻辑通常作为一个参数传到某个方法中。本人觉得可以这样去理解 Predicate，其实例是一个条件,条件是用来判断test(T t)中的参数是否成立，所以最终的关系是“条件.test(t)”。

• • 源码解析
  • 案例分析
  • • test方法
    • and 方法
    • or 方法
    • negate方法
    • not方法
    • isEqual方法
    • 万能方法
  • 总结

package java.util.function;
import java.util.Objects;

@FunctionalInterface
public interface Predicate {
    
    boolean test(T t);
    
    default Predicate and(Predicate other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }
    
    default Predicate negate() {
        return (t) -> !test(t);
    }
    
    default Predicate or(Predicate other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }
    
    static  Predicate isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
    
    @SuppressWarnings("unchecked")
    static  Predicate not(Predicate target) {
        Objects.requireNonNull(target);
        return (Predicate)target.negate();
    }
}

//判断一个数大于0
//因为此接口中只有一个待实现的接口，所以这里基本都会用lamda表达式来编写判断逻辑
Predicate predicate = t -> t > 0;
System.out.println(predicate.test(2));

如果需要经常使用的话，一般会封装成方法。

public boolean test(int i, Predicate predicate) {
        predicate.test(i);
}
//使用
对象.test(2,i->i>0);

需要传入Predicate

//判断一个数大于3，且能被4整除
 Predicate predicate = i->i>3;
 predicate.and(i->i%4==0).test(5);

一般情况如果判断条件少的话我直接会用&&来代替and

//判断一个数大于3，且能被4整除
 Predicate predicate = i->i>3 && i%4==0;
 predicate.test(5);

需要传入Predicate

//判断能被2整除，或者能被4整除
 Predicate predicate = i->i%2==0;
 predicate.and(i->i%4==0).test(8);

同and 一样，如果如果判断条件少的话我直接会用||来代替or

//判断能被2整除，或者能被4整除
 Predicate predicate = i->i%2==0 ||i->i%4==0;
 predicate.test(8);

相当于取非操作，这个方法跟and 和or 不同，它不需要传入Predicate，也是唯一一个不需要传入参数的函数。

//判断一个数不大于2
 Predicate predicate = i->i>2;
 predicate.negate().test(8);

java11 提供的一个静态方法，也是取非操作，对negate进行了封装，需要传入Predicate.

//判断一个数不大于2
//这里需要注意的时，参数上要加上类型转换
Predicate.not(i->(Integer)i>2).test(3);

此方法是一个静态方法，返回值为Predicate,需要传入一个对象，与test中的参数进行比较。

//判断两个字符串是否相等
Predicate.isEqual("str1").test("str2");

本人在工作中通常只写一个方法来处理大部分的判断，这样就不用每次都声明一个Predicate 变量。在函数外将构造好的条件与待判断的对象传入即可。

//万能判断
public static  void multiFunction(T t, Predicate predicate) {
        if (predicate.test(t)) {
            System.out.println(t);
        }
    }
//判断一个字符串长度是否大于2
类名. multiFunction("s1", t -> t.length()>2);

//判断一个数能否被2整除
类名.multiFunction(3, t -> t%2==0);
//判断两个字符串是否相等
 multiFunction("str1", Predicate.isEqual("str2"));

内容很简单，所有的判断都会汇聚到test上，因为test是唯一需要实现的接口，也就是说所有的判断逻辑都是在test中实现的。在java8的Stream中，Predicate使用很广泛，后续的博文中会一一介绍。最后希望本文能帮助大家，祝大家在IT之路上少走弯路，一路绿灯不堵车，测试一性通过，bug秒解！