- Consumer
说明：（1）consumer接口来自java8中引入的Java.util.function包
（2）Consumer是一个功能接口，用来作为lambda表达式或方法引用的任务目标(传递一个参数执行指定的方法)。
功能：Consumer的功能接口是一个接受单一参数并且不返回任何结果的操作。必要时，"结果"可以存在在集合里面，Consumer的功能方法是accept(T t)
- accept : 这是Consumer功能接口的功能方法。accept 方法对给定的参数进行这一操作。
- andThen : 此方法返回一个组合的Consumer，该Consumer先执行原始的Consumer操作，然后按照从左到右的顺序执行给定的andThen操作
代码示例：
1 /*
2 注意consumer接收一个参数，正常不返回数值
3 /*
4 //直接返回String的长度
5 Consumer<String> print = data -> System.out.println(data.length());
6 print.accept("abcdefg");
7 System.out.println("-----------------");
8
9 List<Integer> list = Arrays.asList(1, 2, 3, 4);
10 //集合的每个元素乘以5
11 Consumer<List<Integer>> multiflyFive=i->{
12 for (int j = 0; j < i.size(); j++) {
13 i.set(j,i.get(j)*5);
14 }
15 };
16 //打印每个元素
17 Consumer<List<Integer>> printList=i->{
18 for (int j = 0; j < i.size(); j++) {
19 System.out.print(i.get(j)+" ");
20 }
21 };
22 //每个先乘以5之后再打印
23 //5 10 15 20
24 multiflyFive.andThen(printList).accept(list);
返回结果：
7
-----------------
5 10 15 20
2.BiConsumer
说明：（1）consumer接口来自java8中引入的Java.util.function包
（2）BiConsumer是一个功能接口，用来作为lambda表达式或方法引用的任务目标(传递两个参数执行指定的方法)。
功能：BiConsumer的功能接口是一个接受两个参数并且不返回任何结果的操作。BiConsumer的功能方法是accept(T t, U u)。
- accept : 这是Consumer功能接口的功能方法。accept 方法对给定的参数进行这一操作。
- andThen : 此方法返回一个组合的BiConsumer，该BiConsumer先执行原始的BiConsumer操作，然后按照从左到右的顺序执行给定的andThen操作
代码示例：
1 //拼接map中的key和value，以：间隔
2 BiConsumer<String,Integer> print = (K, V) -> System.out.println(K+":"+V);
3 print.accept("1",2);
4 System.out.println("-----------------");
5
6 Map<String,Integer> map = Maps.newLinkedHashMap();
7 for (int i = 0; i < 3; i++) {
8 map.put(i+"",i);
9 }
10
11 //打印key拼接a
12 BiConsumer<String,Integer> print1=(K,V)->{
13 System.out.println("原始数据--->"+K+":"+V);
14 };
15
16 //打印value乘以2
17 BiConsumer<String,Integer> print2=(K,V)->{
18 System.out.println("数值翻倍--->"+K+":"+V*2);
19 };
20 //打印key拼接a后打印value乘以2
21 for (Map.Entry<String, Integer> entry : map.entrySet()) {
22 print1.andThen(print2).accept(entry.getKey(), entry.getValue());
23 }
返回结果：
1:2
-----------------
原始数据--->0:0
数值翻倍--->0:0
原始数据--->1:1
数值翻倍--->1:2
原始数据--->2:2
数值翻倍--->2:4
3.Supplier
说明：（1）Java Supplier接口来自Java 8中引入的 java.util.function包。
（2）Supplier是一个功能接口，代表结果的提供者。
功能：Supplier的功能接口是不需要接受参数并且获取结果的操作。Supplier的功能方法是get()
代码示例：
//输出四个十以内的随机数
Supplier<Integer> supplier=()->new Random().nextInt(10);
List<Integer> list = Lists.newArrayList();
for (int i = 0; i < 4; i++) {
list.add(supplier.get());
}
list.forEach(i-> System.out.println(i));
返回结果：
7
2
4
5
4. Predicate
说明：（1）Predicate接口来自Java 8中引入的 java.util.function包。
（2）Predicate是一个返回值布尔值的函数。
代码示例：
1 import lombok.Data;
2 import lombok.experimental.Accessors;
3 import org.apache.commons.lang3.StringUtils;
4
5 import java.util.function.Predicate;
6
7 public class Test0807 {
8
9 public static void main(String[] args) {
10 Stu stu1 = new Stu().setAge(20).setName("张三").setSex("男");
11
12 //年龄是否大于20
13 Predicate<Stu> condition1=i->i.getAge()>20;
14 //是否性别是女
15 Predicate<Stu> condition2=i-> StringUtils.equals("女",i.getSex());
16
17 //判断stu1的年龄是否大于20
18 boolean test1 = condition1.test(stu1);
19 System.out.println("test1 = " + test1);//false
20
21 //negate对结果取反
22 boolean test11 = condition1.negate().test(stu1);
23 System.out.println("test11 = " + test11);//false
24
25 //判断stu1是否性别是女
26 boolean test2 = condition2.test(stu1);
27 System.out.println("test2 = " + test2);//false
28
29 //判断stu1是否同时年龄大于20与性别是女
30 stu1.setAge(25);
31 boolean test3 = condition1.and(condition2).test(stu1);
32 System.out.println("test3 = " + test3);//false
33
34 //判断stu1是否年龄大于20或者性别是女
35 boolean test4 = condition1.or(condition2).test(stu1);
36 System.out.println("test4 = " + test4);//true
37
38 //判断stu与stu1是否equals
39 Stu stu = new Stu().setSex("男").setAge(25).setName("张三");
40 boolean test5 = Predicate.isEqual(stu).test(stu1);
41 System.out.println("test5 = " + test5);//true
42 }
43 }
44
45 @Data
46 @Accessors(chain = true)
47 class Stu{
48
49 private String name;
50
51 private Integer age;
52
53 private String sex;
54 }
5. Function
说明：（1）Function接口来自Java 8中引入的 java.util.function包。
（2）Function是一个功能接口，用来作为lambda表达式或方法引用的任务目标(传递一个参数执行指定的方法)。
功能：Function的功能接口是一个接受单一参数并且返回单一结果的操作。
Function的功能方法是R apply(T t);
Function具有以下方法：
代码示例：
1 public class Test0807 {
2
3 public static void main(String[] args) {
4
5 Function<Integer,Integer> multi=i-> i*10;
6 Integer result = multi.apply(10);
7 System.out.println("result = " + result);
8
9 Function<Integer,Integer> add=i -> i + 10;
10 //先加10再乘以10
11 result= multi.compose(add).apply(10);//(10+10)*10
12 System.out.println("result = " + result);
13 //先乘以10再加10
14 result= multi.andThen(add).apply(10);//10*20+10
15 System.out.println("result = " + result);
16 }
17 }
5. BiFunction
说明：（1）BiFunction接口来自Java 8中引入的 java.util.function包。
（2）BiFunction是一个功能接口，用来作为lambda表达式或方法引用的任务目标(传递两个个参数执行指定的方法)。
功能：BiFunction的功能接口是一个接受两个参数并且返回单一结果的操作。
BiFunction的功能方法是R apply(T t, U u);
BiFunction具有以下方法：
- apply: 这是BiFunction功能接口的功能方法。apply方法对给定的参数进行这一操作。
- andThen : 此方法返回一个组合的BiFunction，该BiFunction先执行原始的BiFunctionr操作，然后按照从左到右的顺序执行给定的andThen操作
代码示例：
1 import java.util.function.BiFunction;
2
3 public class Test0807 {
4
5 public static void main(String[] args) {
6 //value*10
7 BiFunction<String,Integer,Integer> biFunction1=(K,V)->{
8 V=V*10;
9 return V;
10 };
11 Integer a = biFunction1.apply("a", 10);
12 System.out.println("a = " + a);//10
13
14 //value+10
15 Integer a1 = biFunction1.andThen(i -> i + 10).apply("a", 10);//10*10+10
16 System.out.println("a1 = " + a1);
17
18
19 //key大写
20 BiFunction<String,Integer,String> biFunction2=(K,V)->{
21 K=K.toUpperCase();
22 return K;
23 };
24 String a2 = biFunction2.apply("a", 10);
25 System.out.println("a2 = " + a2);//A
26
27 //拼接本身
28 String a3 = biFunction2.andThen(i -> i.concat(i)).apply("a", 10);
29 System.out.println("a3 = " + a3);//AA
30
31
32 }
33 }
参考引用：https://blog.csdn.net/m0_46360888/article/details/132161245
标签：Function,BiFunction,Predicate,10,System,接口,println,out From： https://www.cnblogs.com/ahulwj/p/18278619