常用的函数式接口_Consumer接口与常用的函数式接口_Consumer接口的默认方法andThen

标签：andThen 消费 函数 接口 String Consumer name

3.3Consumer接口

　　java.util.function.Consumer<T>

　　　　接口则正好与Supplier接口相反，它不是生产一个数据，而是消费一个数据，其数据类型由泛型决定。 消费者<T`接口则正好与供应商接口相反，它不是生产一个数据，而是消费一个数据，其数据类型由泛型决定。

　　　　Supplier :生产数据； Consumer：消费数据

　　　　Consumer接口是一个消费型接口，泛型执行什么类型，就可以使用accpt方法消费什么类型的数据

　　　　具体这么消费（使用），需要自定义（输出，计算.....）

　　抽象方法：accpt；

　　Consumer接口中包含抽象方法 void accpt（T t），意为消费一个指定泛型的数据

 

　Consumer基本使用　　　　　　

 1 package day01.Demo01_Day016;
 2 
 3 import java.util.function.Consumer;
 4 
 5 /*
 6     　java.util.function.Consumer<T>
 7 　　　　接口则正好与Supplier接口相反，它不是生产一个数据，而是消费一个数据，其数据类型由泛型决定。 消费者<T>接口则正好与供应商接口相反，
 8         它不是生产一个数据，而是消费一个数据，其数据类型由泛型决定
 9         Consumer接口中包含抽象方法 void accpt（T t），意为消费一个指定泛型的数据
10         　Consumer接口是一个消费型接口，泛型执行什么类型，就可以使用accpt方法消费什么类型的数据
11 
12 　　　　具体这么消费（使用），需要自定义（输出，计算.....）
13  */
14 public class Demo01Consumer {
15 
16     /*
17        定义一个方法
18        方法的参数传递一个字符串的姓名
19        方法的参数传递Consumer接口，泛型使用String
20        可以使用Consumer接口消费字符串的姓名
21      */
22     public static void method(String name, Consumer<String> con){
23         con.accept(name);
24     }
25 
26     public static void main(String[] args) {
27         //调用method方法，传递字符串姓名，方法的另一个参数是Consumer接口，是一个函数式接口，所以可以传递Lambda表达式
28         method("莫凡",(String name)->{
29             //对传递的字符串进行消费
30             //消费方式：直接输出字符串
31             System.out.println(name);
32 
33             //消费方式：把字符串进行反转输出
34             String mo = new StringBuffer(name).reverse().toString();
35             System.out.println(mo);
36         });
37     }
38 }

 

默认方法：andThen

　　andThen作用：它可以将两个Consumer接口连接到一起，也可以说组合到一起

　　下面就是andThen jdk源码

  default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }

　　andThen方法不管有多少个Consumer接口，可以一直往后累加

 1 package day01.Demo01_Day016;
 2 /*
 3     Consumer接口的默认方法andThen
 4     作用：需要两个Consumer接口，可以将两个Consumer接口组合到一起，在对数据进行消费
 5 
 6     例如:
 7     Consumer<String> con1
 8     Consumer<String> con2
 9     String s = "hello";
10     con1.accept(s);
11     con2.accept(s);
12     连接两个consumer接口  在进行消费
13     con1.andThen(con2).accept(s);：谁写谁先消费
14  */
15 import java.util.function.Consumer;
16 
17 public class Demo02Consumer {
18    // 定义一个方法 方法的参数传递一个字符串和两个Consumer接口方法的参数传递Consumer接口，泛型使用String
19     public static void meoth(String name, Consumer<String>con1,Consumer<String>con2){
20         //con1.accept(name);
21         //con2.accept(name);
22         //使用andThen方法，把两个Consumer接口连接到一起，消费数据
23         con1.andThen(con2).accept(name);//con1连接con2，先执行con1消费数据再执行con2消费数据
24     }
25     public static void main(String[] args) {
26         //调用method方法，传递一个字符串两个lambda表达式
27         meoth("quanzhifashi",
28                 (t)->{
29                 //消费方式：把字符串转换为大写输出
30                     System.out.println(t.toUpperCase());
31                 },
32                 (t)->{
33                     //消费方式：把字符串转换为小写输出
34                     System.out.println(t.toLowerCase());
35                 });
36     }
37 }

 

标签：andThen,消费,函数,接口,String,Consumer,name
From： https://www.cnblogs.com/x3449/p/16778282.html