1.Consumer学习

    Function包中Consumer的使用：
    java.util.function中 Function, Supplier, Consumer, Predicate和其他函数式接口广泛用在支持lambda表达式的API中。这些接口有一个抽象方法，会被lambda表达式的定义所覆盖。
    Consumer的作用顾名思义,是给定义一个参数,对其进行(消费)处理,处理的方式可以是任意操作.

    1. @FunctionalInterface
    2. public interface Consumer<T> {
    4.     void accept(T t);
    6.     default Consumer<T> andThen(Consumer<? super T> after) {
    7.         Objects.requireNonNull(after);
    8.         return (T t) -> { accept(t); after.accept(t); };
    9.     }
    10. }

    其核心方法如下:

    • void accept(T t);
      对给定的参数T执行定义的操作
    • default Consumer andThen(Consumer<? super T> after)
      对给定的参数T执行定义的操作执行再继续执行after定义的操作

    下面对上述方法进行实例测试：
    比如将给定的一批用户里面的名称为”lisi”且年龄大于22岁的用户都给打包起来

    1.  List<Person> lisiList = new ArrayList<>();
    2.         Consumer <Person> consumer  =  x -> {
    3.             if (x.name.equals("lisi")){
    4.                 lisiList.add(x);
    5.             }
    6.         };
    8.         consumer = consumer.andThen(
    9.            x -> lisiList.removeIf(y -> y.age < 23)
    10.         );
    12.         Stream.of(
    13.                 new Person(21,"zhangsan"),
    14.                 new Person(22,"lisi"),
    15.                 new Person(23,"wangwu"),
    16.                 new Person(24,"wangwu"),
    17.                 new Person(23,"lisi"),
    18.                 new Person(26,"lisi"),
    19.                 new Person(26,"zhangsan")
    20.         ).forEach(consumer);
    22.         System.out.println(JSON.toJSONString(lisiList));
    1. /**    
    2.      * consumer接口测试    
    3.      */    
    4.     @Test    
    5.     public void test_Consumer() {    
    6.         //① 使用consumer接口实现方法    
    7.         Consumer<String> consumer = new Consumer<String>() {    
    9.             @Override    
    10.             public void accept(String s) {    
    11.                 System.out.println(s);    
    12.             }    
    13.         };    
    14.         Stream<String> stream = Stream.of("aaa", "bbb", "ddd", "ccc", "fff");    
    15.         stream.forEach(consumer);    
    17.         System.out.println("********************");    
    19.         //② 使用lambda表达式，forEach方法需要的就是一个Consumer接口    
    20.         stream = Stream.of("aaa", "bbb", "ddd", "ccc", "fff");    
    21.         Consumer<String> consumer1 = (s) -> System.out.println(s);//lambda表达式返回的就是一个Consumer接口    
    22.         stream.forEach(consumer1);    
    23.         //更直接的方式    
    24.         //stream.forEach((s) -> System.out.println(s));    
    25.         System.out.println("********************");    
    27.         //③ 使用方法引用，方法引用也是一个consumer    
    28.         stream = Stream.of("aaa", "bbb", "ddd", "ccc", "fff");    
    29.         Consumer consumer2 = System.out::println;    
    30.         stream.forEach(consumer);    
    31.         //更直接的方式    
    32.         //stream.forEach(System.out::println);    
    33.     }

    仔细的看一下你会发现，lambda 表达式返回值就是一个 Consumer；所以forEach 方法可以使用 lamdda 表达式作为参数了。
    除了上面使用的 Consumer 接口，还可以使用下面这些 Consumer 接口。
    IntConsumer、DoubleConsumer、LongConsumer、BiConsumer

    Consumer总结
    看完上面的实例我们可以总结为几点。
    ① Consumer是一个接口，并且只要实现一个 accept 方法，就可以作为一个    “消费者”输出信息。
    ② 其实，lambda 表达式、方法引用的返回值都是     Consumer 类型**，所以，他们能够作为 forEach 方法的参数，并且输出一个值。

    2.Supplier实例
    https://blog.csdn.net/sihai12345/article/details/99374583