java8新特性

1. '::'用法

   1. 类名::方法
      Test::print;

   这个方法必须是static的。

   list.forEach(TestJava8::printItem)

   list.forEach(item ->System.out.println(item.name));

   把方法作为方法的参数。

2. Consumer<T> consumer = TestJava8::printItem;

consumer.accept(T);

这样,只要T对象，经过accept，都会去执行printItem这个方法。

3. Predicate<T>;作为函数的形参，实参传入一个静态的方法，而且，此方法必须返回一个 Boolean值。在执行的方法中，使用predicate.test(T)。感觉像一个过滤器。

   predicateA.and(predicateB).test(T); 使用两个条件去过滤；

   predicateA.or(predicateB).test(T); 使用两个条件去过滤；

   predicateA.negate().test(T): 执行反条件；

4. Lambda： 把方法体作为参数进行传递。lambda的出现时为了替换匿名内部类的冗余。

   1. 可以使用lambda表达式外部的变量，但是，要保证这个变量是final的，若是在lambda之后，还被更改了，则会导致lambda报错。
   2. 更好的是使用方法引用：对象::方法
      1. 指向静态方法的引用；
      2. 指向任意类型实例方法的方法引用；
      3. 指向现有对象的实例方法的方法引用；

5. Stream：针对的是collections这些集合的，把List，Array之类的大批量数据，化为流，链式编程，可以更加精简的处理这些数据。 集合是讲的数据，流讲的是计算。流只能被消费一次。

   1. filter：条件
   2. map：需要收集的字段
   3. skip：跳过前面满足条件的多少条数据
   4. limit：只要前面多条数据
   5. count：得到收集的条数
   6. collect(toList())：把符合条件的数据，收集成一个list；

   查找和匹配：

    allMatch 、 anyMatch 、 noneMatch 、 findFirst 和 findAny ；find配合optional，这样不会出现空指针。
   

   归约：reduce(初始值， BiFunction)；最后得到一个值。

   Stream转换成数值流：list.stream().mapToInt()->IntStream;

   数值流转换成Stream：IntStream.boxed();

   生成数值范围：IntStream.range(1,100)/rangeClosed(1, 100],前者不含末尾，后者包含末尾。
   

6. 菱形继承： 一个类可以实现多个接口， 但是每个接口中都有同样名字的函数。导致，开发者不知道使用的是哪个类。

7. Optional<T>: 使用它可以避免nullpointer的出现。

8. 函数式接口： 只要定义了一个抽象方法，那么这个接口就是函数式接口。继承的抽象方法不算；

9. @FunctionalInterface：加上这个注解就是函数式接口，但是只能有一个抽象方法，可以检测当前接口是否是一个函数式接口。

10. 环绕执行模式： 比如对数据库的操作，打开资源，进行一些处理，关闭资源。可以配合java7中的try安全处理资源。对于不同的处理资源要求，可以使用函数式接口，实现不同的需求。

11. 方法引用：

    1. 构造函数：

       1. 无参： Supplier<Apple> supplier = Apple::new;

            Apple apple = supplier.get();
          

       2. 一参：Function<String, Apple> function = Apple::new;

             Apple apple = function.apply("Red");
          

       3. 二参：BiFunction<String, Integer, Apple> = Apple::new;

               Apple apple = function.apply("Red", 12);
          

       4. 多参： 自定义接口：

       interface TriFunction<T, U, V, R>{

        R apply(T t, U u, V v);
       

       }

12. 比较器复合：可以进行按照不同优先级的元素进行排序

    List.sort(comparator.comparing(Apple::getWeight)).reversed().thenComparing(Apple::getColor);

13. 谓词复合：可以对多个条件进行连接：negate,and,or

    Predicate<Apple> predicate = redApp.and(a->a.getWeight() > 150).or(a->a.getColor == "Green");

14. 函数复合：andThen，compose； andThen，是先执行f,然后是g，换成compose之后，执行顺序刚好相反。

    Function<Integer, Integer> f = x -> x + 1;

    Function<Integer, Integer> g = x -> x * 2;

    Function<Integer, Integer> h = f.andThen(g);

    int result = h.apply(1);

https://blog.csdn.net/weixin_29135773/article/details/54095573

https://www.cnblogs.com/aoeiuv/p/5911692.html