Java 8函数式接口Function、Consumer、Predicate、Supplier
基础索引：https://docs.oracle.com/javase/8/docs/api/
主要内容:
1: 自定义函数式接口
2: 函数式编程
3: 常用函数式接口
3.1 Supplier 你要作为一个供应者,自己生产数据
3,2 Consumer 你要作为一个消费者,利用已经准备数据
3.3 Function 输入一个或者两个不同或者相同的值转为另一个值
3.4 Predicate 输入一个或者两个不同或者相同的值总是输出boolean
3.5 UnaryOperator 输入一个值转换为相同值输出
3.6 BinaryOperator 输入两个相同类型的值 转为相同类型的值输出
主要语法:
- () -> 代表了 lambda的一个表达式
- 单行代码无需写return (无论函数式接口有没有返回值),花括号
- 多行代码必须写花括号,有返回值的一定要写返回值
- 单行代码且有参数的情况下可以不写 () 如 s->System.out.println(s)
- (T t)中的参数类型可写可不写
1: 函数式接口
1.1 概念
函数式接口在java中是指:有且仅有一个抽象方法的接口
函数式接口，即适用于函数式编程场景的接口。而java中的函数式编程体现就是Lambda，所以函数式接口就是可以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导。
备注：“语法糖”是指使用更加方便，但是原理不变的代码语法。例如在遍历集合时使用的for-each语法，其实底层的实现原理仍然是迭代器，这便是“语法糖”。从应用层面来讲，Java中的Lambda可以被当做是匿名内部类的“语法糖”，但是二者在原理上是不同的。
1.2 格式
接口中只能存在一个抽象方法
修饰符 interface 接口名称{
public abstract 返回值 方法名称(参数列表)
// 其他方式
}
// public abstract 可以不写 编译器自动加上
修饰符 interface 接口名称{
返回值 方法名称(参数列表)
// 其他方式
}
1.3@FunctionalInterface注解
@FunctionalInterface // 标明为函数式接口
public abstract MyFunctionInterface{
void mrthod(); //抽象方法
}
一旦使用该注解来定义接口，编译器将会强制检查该接口是否确实有且仅有一个抽象方法，否则将会报错。需要注意的是，即使不使用该注解，只要满足函数式接口的定义，这仍然是一个函数式接口，使用起来都一样。(该接口是一个标记接口)
1.4 调用自定义函数接口
public class Test_Functional {
// 定义一个含有函数式接口的方法
public static void doSomthing(MyFunctionalInterface functionalInterface) {
functionalInterface.mehod();//调用自定义函数式接口的方法
}
public static void main(String[] args) {
//调用函数式接口的方法
doSomthing(()->System.out.println("excuter lambda!"));
}
}
2:函数式编程
2.1:lambda的延迟执行
有些场景的代码执行后，结果不一定会被使用，从而造成性能浪费。而Lambda表达式是延迟执行的，这正好可以作为解决方案，提升性能。
性能浪费的日志案例
注：日志可以帮助我们快速的定位问题，记录程序运行过程中的情况，以便项目的监控和优化。一种典型的场景就是对参数进行有条件使用，
例如对日志消息进行拼接后，在满足条件的情况下进行打印输出：
public class Demo01Logger {
private static void log(int level, String msg) {
if (level == 1) {
System.out.println(msg);
}
}
public static void main(String[] args) {
String msgA = "Hello";
String msgB = "World";
String msgC = "Java";
log(1, msgA + msgB + msgC);//级别1 不一定能够满足 但是 字符串连接操作还是执行了 那么字符串的拼接操作就白做了，存在性能浪费
}
}
备注：SLF4J是应用非常广泛的日志框架，它在记录日志时为了解决这种性能浪费的问题，并不推荐首先进行字符串的拼接，而是将字符串的若干部分作为可变参数(包装为数组)传入方法中，
仅在日志级别满足要求的情况下才会进行字符串拼接。例如： LOGGER.debug(“变量{}的取值为{}。”, “os”, “macOS”) ，其中的大括号 {} 为占位符。如果满足日志级别要求，
则会将“os”和“macOS”两个字符串依次拼接到大括号的位置；否则不会进行字符串拼接。这也是一种可行解决方案，但Lambda可以做到更好。
体验Lambda的更优写法
@FunctionalInterface
public interface MessageBuilder {
String buildMessage();
}
public class Demo02LoggerLambda {
private static void log(int level, MessageBuilder builder) {
if (level == 1) {
System.out.println(builder.buildMessage());// 实际上利用内部类 延迟的原理,代码不相关 无需进入到启动代理执行
}
}
public static void main(String[] args) {
String msgA = "Hello";
String msgB = "World";
String msgC = "Java";
log(2,()->{
System.out.println("lambda 是否执行了");
return msgA + msgB + msgC;
});
}
}
2.2 使用Lambda作为参数和返回值
假设有一个 方法使用该函数式接口作为参数，那么就可以使用Lambda进行传参.如线程中的Runable接口
public class Runnable {
private static void startThread(Runnable task) {
new Thread(task).start();
}
public static void main(String[] args) {
startThread(() ‐> System.out.println("线程任务执行！"));
}
}
如果一个方法的返回值类型是一个函数式接口，那么就可以直接返回一个Lambda表达式(类始于new 内部类的实现方式 方法中可以实现构造内部类)
public class lambda_Comparator {
//下面给出 lambda 以及实际替代的内部类写法
private static Comparator<String> newComparator(){
return (a,b)->b.length()-a.length();
}
private static Comparator<String> newComparator1(){
return new Comparator<String>() {
@Override
public int compare(String a, String b) {
return b.length()-a.length();
}
};
}
public static void main(String[] args) {
String[] array={"abc","ab","abcd"};
System.out.println(Arrays.toString(array));
Arrays.sort(array, newComparator1()); // 方式一
Arrays.sort(array,(a,b)->b.length()-a.length());//更简单的方式
System.out.println(Arrays.toString(array));
}
}
3:常用函数式接口
3.1 Supplier接口(供应接口)
java.util.function.Supplier<T> 接口仅包含一个无参的方法： T get() 。用来获取一个泛型参数指定类型的对象数据。由于这是一个函数式接口，
这也就意味着对应的Lambda表达式需要“对外提供”一个符合泛型类型的对象数据。
public class Test_Supplier {
private static String test_Supplier(Supplier<String> suply) {
return suply.get(); //供应者接口
}
public static void main(String[] args) {
// 产生的数据作为 sout 作为输出
System.out.println(test_Supplier(()->"产生数据"));
System.out.println(String.valueOf(new Supplier<String>() {
@Override
public String get() {
return "产生数据";
}
}));
}
}
3.2 练习：求数组元素最大值
public class use_Supplier_Max_Value {
private static int getMax(Supplier<Integer> suply) {
return suply.get();
}
public static void main(String[] args) {
Integer [] data=new Integer[] {6,5,4,3,2,1};
int reslut=getMax(()->{
int max=0;
for (int i = 0; i < data.length; i++) {
max=Math.max(max, data[i]);
}
return max;
});
System.out.println(reslut);
}
}
3.3 Consumer接口
java.util.function.Consumer<T> 接口则正好与Supplier接口相反，它不是生产一个数据，而是消费一个数据，其数据类型由泛型决定
抽象方法：accept
Consumer 接口中包含抽象方法 void accept(T t) ，意为消费一个指定泛型的数据。基本使用如：
public class Test_Comsumer {
public static void generateX(Consumer<String> consumer) {
consumer.accept("hello consumer");
}
public static void main(String[] args) {
generateX(s->System.out.println(s));
}
}
默认方法：andThen
如果一个方法的参数和返回值全都是 Consumer 类型，那么就可以实现效果：消费数据的时候，首先做一个操作，然后再做一个操作，实现组合
default Consumer<T> andThen(Consumer<? super T> after) {
Objects.requireNonNull(after);
return (T t) ‐> { accept(t); after.accept(t); };
//1: 返回值为Consumer 那么需要 ()-> 表示函数式接口
//2: accept(t);为生产一个数据供应给 (T t)中的t
//3: after.accept(t);为利用这个t再次生成新的函数式接口 实现类始于builder的设计模式
}
3.4 练习：格式化打印信息
请按照格式“ 姓名：XX。性别：XX。 ”的格式将信息打印出来
public class use_Consumer_FormattorName {
public static void formattorPersonMsg(Consumer<String[]> con1, Consumer<String[]> con2) {
// con1.accept(new String[]{ "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男" });
// con2.accept(new String[]{ "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男" });
// 一句代码搞定
con1.andThen(con2).accept(new String[] { "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男" });
}
public static void main(String[] args) {
formattorPersonMsg((s1) -> {
for (int i = 0; i < s1.length; i++) {
System.out.print(s1[i].split("\\,")[0] + " ");
}
}, (s2) -> {
System.out.println();
for (int i = 0; i < s2.length; i++) {
System.out.print(s2[i].split("\\,")[1] + " ");
}
});
System.out.println();
printInfo(s->System.out.print(s.split("\\,")[0]),
s->System.out.println(","+s.split("\\,")[1]),datas);
}
// 自身自销 有意思
private static void printInfo(Consumer<String> one, Consumer<String> two, String[] array) {
for (String info : array) { // 这里每次产生 {迪丽热巴。性别：女 } String 数据 逻辑那边顺序处理就行
one.andThen(two).accept(info); // 姓名：迪丽热巴。性别：女。 } }
}
}
}
3.5 Predicate接口
有时候我们需要对某种类型的数据进行判断，从而得到一个boolean值结果。这时可以使用java.util.function.Predicate<T> 接口
(s)-> 函数式接口有参数 表示有有产生数据
(s)-> 具体的返回数据 看要是否原函数式接口给出了
抽象方法：test
Predicate 接口中包含一个抽象方法： boolean test(T t) 。用于条件判断的场景：
默认方法：and or nagte (取反)
既然是条件判断，就会存在与、或、非三种常见的逻辑关系。其中将两个 Predicate 条件使用“与”逻辑连接起来实
现“并且”的效果时,类始于 Consumer接口 andThen()函数 其他三个雷同
default Predicate<T> and(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) ‐> test(t) && other.test(t);
}
判断字符串是否包含o h 的and or not
public class Use_Predicate {
// 判断字符串是否存在o 即使生产者 又是消费者接口
private static void method_test(Predicate<String> predicate) {
boolean b = predicate.test("OOM SOF");
System.out.println(b);
}
// 判断字符串是否同时存在o h 同时
private static void method_and(Predicate<String> predicate1,Predicate<String> predicate2) {
boolean b = predicate1.and(predicate2).test("OOM SOF");
System.out.println(b);
}
//判断字符串是否一方存在o h
private static void method_or(Predicate<String> predicate1,Predicate<String> predicate2) {
boolean b = predicate1.or(predicate2).test("OOM SOF");
System.out.println(b);
}
// 判断字符串不存在o 为真 相反结果
private static void method_negate(Predicate<String> predicate) {
boolean b = predicate.negate().test("OOM SOF");
System.out.println(b);
}
public static void main(String[] args) {
method_test((s)->s.contains("O"));
method_and(s->s.contains("O"), s->s.contains("h"));
method_or(s->s.contains("O"), s->s.contains("h"));
method_negate(s->s.contains("O"));
}
}
静态方法：not isEquals
返回值为Predicate<T> 说明最终由tets为最终处理结果
static <T> Predicate<T> not(Predicate<? super T> target) {
Objects.requireNonNull(target);
return (Predicate<T>)target.negate();
}
boolean b = Predicate.not((String s)->s.contains("J")).test("Java"); // 直接构造lambda 断言可能包
// 使用静态方法判断是否为同一个对象
private static void method_isEqual(Predicate<String> predicate) {
boolean b = Predicate.isEqual(predicate).test(predicate);
System.out.println(b);
}
3.6 练习：集合信息筛选
请通过 Predicate 接口的拼装将符合要求的字符串筛选到集合
ArrayList 中，需要同时满足两个条件：
\1. 必须为女生；
\2. 姓名为4个字。
/**
* 1. 必须为女生；
* 2. 姓名为4个字。
*/
public static void main(String[] args) {
String[] array = { "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男", "赵丽颖,女" };
getFemaleAndname((s) -> s.split("\\,")[0].length() == 4,
(s) -> s.split("\\,")[1].equals("女"), array);
}
private static void getFemaleAndname(Predicate<String> one,
Predicate<String> two, String[] arr) {
for (String string : arr) {
if (one.and(two).test(string)) {
System.out.println(string);
}
}
}
3.7 Function接口
java.util.function.Function<T,R> 接口用来根据一个类型的数据得到另一个类型的数据，前者称为前置条件，后者称为后置条件
将T 转为 R
// 将数字转换为String类型
private static void numberToString(Function<Number, String> function) {
String apply = function.apply(12);
System.out.println("转换结果:"+apply);
}
public static void main(String[] args) {
numberToString((s)->String.valueOf(s));
}
默认方法 andThen compose():
Function 接口中有一个默认的 andThen compose方法，用来进行组合操作。JDK源代码如：
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));// 先执行调用者,再执行after的apply方法
} // 这里的V 一个是作为输入值 一个是作为输出值 按照调用的顺序的不同 对于 T V 做输入 输出的顺序也不同 注意看
default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
Objects.requireNonNull(before);
return (V v) -> apply(before.apply(v));// 先执行before的apply方法,后执行调用者apply方法
}
注意调用的先后顺序
// 静态方法
private static void method_andThen(Function<Integer, Integer> f1,Function<Integer, Integer> f2) {
Integer apply = f1.andThen(f2).apply(2);
System.out.println(apply);
}
private static void method_compose(Function<Integer, Integer> f1,Function<Integer, Integer> f2) {
Integer apply = f1.compose(f2).apply(2);
System.out.println(apply);
}
public static void main(String[] args) {
numberToString((s)->String.valueOf(s));
method_andThen(s->s+1, s->s=s*2);//6
method_compose(s->s+1, s->s=s*s);//5
}
静态方法 identity
输入对象就是输出对象
//返回一个执行了apply()方法之后只会返回输入参数的函数对象
Object apply = Function.identity().apply(2);
System.out.println(apply);
3.8 练习：自定义函数模型拼接
题目
请使用 Function 进行函数模型的拼接，按照顺序需要执行的多个函数操作为：
String str = “赵丽颖,20”;
\1. 将字符串截取数字年龄部分，得到字符串；
\2. 将上一步的字符串转换成为int类型的数字；
\3. 将上一步的int数字累加100，得到结果int数字。
Main{String str = "赵丽颖,20";
solotion(s->s.split("\\,")[1],s->Integer.parseInt(s),s->s+=100,str);
}
private static void solotion(Function<String, String> o1, Function<String,
Integer> o2, Function<Integer, Integer> o3, String str) {
Integer apply = o1.andThen(o2).andThen(o3).apply(str);
System.out.println(apply);
}
4.扩展函数接口
扩展函数接口太多了, 但是掌握了基本的五大函数接口,相信你 其他函数接口都能够掌握,下面有时间会更新相关函数接口的用法
UnaryOperator：一元操作符，Function的子类，只是该接口的输入参数和返回结果必须是同一类型。
BinaryOperator：二元操作符，BiFunction的子类，
BiFunction：比Function高级一点，可以接收两个参数，应用后也还是返回一个结果。
BiConsumer：同样比Consumer高级一点，可以接收两个参数进行消费而不需返回结果。
BiPredicate：同样比Predicate高级一点，可以接收两个参数，判断后也还是返回一个bool值。
总体的，可以参考网上这张图，图中绿色表示主要引入的新接口，其他接口基本上都是为了支持基本类型而添加的接口。
4.1: Operator 相同类型互相转换的接口
BinaryOperator<Integer>的andthen() 方法不支持两个链接操作 也就是不需要再次BinaryOperator<Integer> 因为源代码规定不允许使用两次输入
// 单个同类型操作
UnaryOperator<String> u_str=(s)->s.split(" ")[0];
UnaryOperator<String> u_str1=(s)->s.concat(" ok");
String apply = u_str.andThen(u_str1).apply("lambda Ok");
System.out.println(apply);
String apply1 = u_str.compose(u_str1).apply("lambda Ok");
System.out.println(apply1);
// 两个同类型操作
BinaryOperator<Integer> way_add=(k,v)->k+v;
BinaryOperator<Integer> way_mul=(k,v)->k*v;
Integer res1 = way_add.apply(1,2);
Integer res2 = way_mul.apply(1,2);
System.out.println(res1);
System.out.println(res2);
Function<Integer, Integer> x=(k)->k*2;
//注意不允许 way_add.andThen(way_mul).apply(1,2); andThen需要的是Function
Integer apply2 = way_add.andThen(x).apply(1,2);
System.out.println(apply2);
// 最大值 最小值 (这里不能连续写 连U型apply 要报错)
BinaryOperator<Integer> bi_max = BinaryOperator.maxBy(Comparator.naturalOrder());
BinaryOperator<Integer> bi_min = BinaryOperator.minBy(Comparator.naturalOrder());
Integer res3 = bi_max.apply(2, 3);
Integer res4 = bi_max.apply(3, 2);
System.out.println(res3);
System.out.println(res4);
—————————————————————————————————————————————————————————————————————————————-
Function接口
Java8 添加了一个新的特性Function，顾名思义这一定是一个函数式的操作。我们知道Java8的最大特性就是函数式接口。所有标注了@FunctionalInterface注解的接口都是函数式接口，具体来说，所有标注了该注解的接口都将能用在lambda表达式上。
标注了@FunctionalInterface的接口有很多，但此篇我们主要讲Function，了解了Function其他的操作也就很容易理解了。
@FunctionalInterface
public interface Function<T, R> {
R apply(T t);
/**
* @return a composed function that first applies the {@code before}
* function and then applies this function
*/
default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
Objects.requireNonNull(before);
return (V v) -> apply(before.apply(v));
}
/**
* @return a composed function that first applies this function and then
* applies the {@code after} function
*/
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));
}
}为了方便地阅读源码，我们需要了解一些泛型的知识，如果你对泛型已经很熟悉了，那你可以跳过这段 。
泛型是JDK1.5引入的特性，通过泛型编程可以使编写的代码被很多不同的类型所共享，这可以很好的提高代码的重用性。因为本篇重点不是介绍泛型，所以我们只关注上述Function源码需要用到的泛型含义。
1. 泛型类
泛型类使用<T>来表示该类为泛型类，其内部成员变量和函数的返回值都可以为泛型<T> ，Function源码的标识为<T,R>，也就是两个泛型参数，此处不再赘述，具体泛型类可以看网上的文章。
2. 泛型方法和通配符
在方法修饰符的后面加一个<T>表明该方法为泛型方法，如Function 的源码里的compose方法的<V>。通配符也很好理解，还是compose的例子，我们可以看到compose的参数为一个Function类型，其中Functin的参数指定了其第一个参数必须是V的父类，第二个参数必须继承T，也就是T的子类。
源码解析
1.apply
讲完了上面这些就可以开始研究源码了。
首先我们已经知道了Function是一个泛型类，其中定义了两个泛型参数T和R，在Function中，T代表输入参数，R代表返回的结果。也许你很好奇，为什么跟别的java源码不一样，Function 的源码中并没有具体的逻辑呢？
其实这很容易理解，Function 就是一个函数，其作用类似于数学中函数的定义 ，（x,y）跟的作用几乎一致。
y=f(x)y=f(x)
所以Function中没有具体的操作，具体的操作需要我们去为它指定，因此apply具体返回的结果取决于传入的lambda表达式。
R apply(T t);举个例子：
public void test(){
Function<Integer,Integer> test=i->i+1;
test.apply(5);
}
/** print:6*/我们用lambda表达式定义了一个行为使得i自增1，我们使用参数5执行apply，最后返回6。这跟我们以前看待Java的眼光已经不同了，在函数式编程之前我们定义一组操作首先想到的是定义一个方法，然后指定传入参数，返回我们需要的结果。函数式编程的思想是先不去考虑具体的行为，而是先去考虑参数，具体的方法我们可以后续再设置。
再举个例子：
public void test(){
Function<Integer,Integer> test1=i->i+1;
Function<Integer,Integer> test2=i->i*i;
System.out.println(calculate(test1,5));
System.out.println(calculate(test2,5));
}
public static Integer calculate(Function<Integer,Integer> test,Integer number){
return test.apply(number);
}
/** print:6*/
/** print:25*/我们通过传入不同的Function，实现了在同一个方法中实现不同的操作。在实际开发中这样可以大大减少很多重复的代码，比如我在实际项目中有个新增用户的功能，但是用户分为VIP和普通用户，且有两种不同的新增逻辑。那么此时我们就可以先写两种不同的逻辑。除此之外，这样还让逻辑与数据分离开来，我们可以实现逻辑的复用。
当然实际开发中的逻辑可能很复杂，比如两个方法F1,F2都需要两个个逻辑AB，但是F1需要A->B，F2方法需要B->A。这样的我们用刚才的方法也可以实现，源码如下：
public void test(){
Function<Integer,Integer> A=i->i+1;
Function<Integer,Integer> B=i->i*i;
System.out.println("F1:"+B.apply(A.apply(5)));
System.out.println("F2:"+A.apply(B.apply(5)));
}
/** F1:36 */
/** F2:26 */也很简单呢，但是这还不够复杂，假如我们F1,F2需要四个逻辑ABCD，那我们还这样写就会变得很麻烦了。
2.compose和andThen
compose和andThen可以解决我们的问题。先看compose的源码
default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
Objects.requireNonNull(before);
return (V v) -> apply(before.apply(v));
}compose接收一个Function参数，返回时先用传入的逻辑执行apply，然后使用当前Function的apply。
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));
}andThen跟compose正相反，先执行当前的逻辑，再执行传入的逻辑。
这样说可能不够直观，我可以换个说法给你看看
compose等价于B.apply(A.apply(5))，而andThen等价于A.apply(B.apply(5))。
public void test(){
Function<Integer,Integer> A=i->i+1;
Function<Integer,Integer> B=i->i*i;
System.out.println("F1:"+B.apply(A.apply(5)));
System.out.println("F1:"+B.compose(A).apply(5));
System.out.println("F2:"+A.apply(B.apply(5)));
System.out.println("F2:"+B.andThen(A).apply(5));
}
/** F1:36 */
/** F1:36 */
/** F2:26 */
/** F2:26 */我们可以看到上述两个方法的返回值都是一个Function，这样我们就可以使用建造者模式的操作来使用。
B.compose(A).compose(A).andThen(A).apply(5);Predicate接口
Predicate的源码跟Function的很像，我们可以对比这两个来分析下。直接上Predicate的源码：
public interface Predicate<T> {
/**
* Evaluates this predicate on the given argument.
*/
boolean test(T t);
/**
* Returns a composed predicate that represents a short-circuiting logical
* AND of this predicate and another. When evaluating the composed
* predicate, if this predicate is {@code false}, then the {@code other}
* predicate is not evaluated.
*/
default Predicate<T> and(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) && other.test(t);
}
/**
* Returns a predicate that represents the logical negation of this
* predicate.
*/
default Predicate<T> negate() {
return (t) -> !test(t);
}
/**
* Returns a composed predicate that represents a short-circuiting logical
* OR of this predicate and another. When evaluating the composed
* predicate, if this predicate is {@code true}, then the {@code other}
* predicate is not evaluated.
*/
default Predicate<T> or(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) || other.test(t);
}
/**
* Returns a predicate that tests if two arguments are equal according
* to {@link Objects#equals(Object, Object)}.
*/
static <T> Predicate<T> isEqual(Object targetRef) {
return (null == targetRef)
? Objects::isNull
: object -> targetRef.equals(object);
}
}Predicate是个断言式接口其参数是，也就是给一个参数T，返回boolean类型的结果。跟Function一样，Predicate的具体实现也是根据传入的lambda表达式来决定的。
boolean test(T t);接下来我们看看Predicate默认实现的三个重要方法and，or和negate
default Predicate<T> and(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) && other.test(t);
}
default Predicate<T> negate() {
return (t) -> !test(t);
}
default Predicate<T> or(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) || other.test(t);
}这三个方法对应了java的三个连接符号&&、||和!，基本的使用十分简单，我们给一个例子看看：
int[] numbers= {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
List<Integer> list=new ArrayList<>();
for(int i:numbers) {
list.add(i);
}
Predicate<Integer> p1=i->i>5;
Predicate<Integer> p2=i->i<20;
Predicate<Integer> p3=i->i%2==0;
List test=list.stream().filter(p1.and(p2).and(p3)).collect(Collectors.toList());
System.out.println(test.toString());
/** print:[6, 8, 10, 12, 14]*/我们定义了三个断言p1,p2,p3。现在有一个从1~15的list，我们需要过滤这个list。上述的filter是过滤出所有大于5小于20，并且是偶数的列表。
假如突然我们的需求变了，我们现在需要过滤出奇数。那么我不可能直接去改Predicate，因为实际项目中这个条件可能在别的地方也要使用。那么此时我只需要更改filter中Predicate的条件。
List test=list.stream().filter(p1.and(p2).and(p3.negate())).collect(Collectors.toList());
/** print:[7, 9, 11, 13, 15]*/我们直接对p3这个条件取反就可以实现了。是不是很简单？
isEqual这个方法的返回类型也是Predicate，所以我们也可以把它作为函数式接口进行使用。我们可以当做==操作符来使用。
List test=list.stream()
.filter(p1.and(p2).and(p3.negate()).and(Predicate.isEqual(7)))
.collect(Collectors.toList());
/** print:[7] */