Java 8 Stream API

Java 8 介绍

1. Java 8 发版于 2014 年，多年过去，目前依旧是最常用的 JDK 版本
2. Java 8 在增强代码可读性、简化代码方面，增加了很多功能，比如 Lambda、Stream 流操作、并行流（ParallelStream）、Optional 可空类型、新的日期时间类型等
3. Lambda 表达式配合 Stream 流操作为我们日常编码极大的提升了效率

Lambda 表达式

1. 匿名类内部类虽然没有类名，但还是要给出方法定义

2. Lambda 表达式的初衷是进一步简化匿名类的语法

3. 在实现上，Lambda 表达式并不是匿名类的语法糖

4. Lambda 和匿名类的示例

   public class ThreadCreator {
       public static Thread createThreadByAnonymous() {
           return new Thread(new Runnable() {
               @Override
               public void run() {
                   System.out.println("Anonymous thread print");
               }
           });
       }
   
       public static Thread createThreadByLambda() {
           return new Thread(() -> {
               System.out.println("Lambda thread print");
           });
       }
   }

5. Lambda 表达式如何匹配类型接口？=> 函数式接口

   函数式接口是一种只有单一抽象方法的接口，使用 @FunctionalInterface 来描述，可以隐式地转换成 Lambda 表达式

   使用 Lambda 表达式创建函数式接口的示例， 可以让函数成为程序的一等公民，从而像普通数据一样当作参数传递

   JDK 的 java.util.function 中提供了许多原生的函数式接口，如 Supplier

   
   @FunctionalInterface
   public interface Supplier<T> {
   
       /**
        * Gets a result.
        *
        * @return a result
        */
       T get();
   }

   使用 Lamda 或方法引用来得到函数式接口的实例

   // 使用 Lambda 表达式提供 Supplier 接口实现，返回 OK 字符串
   Supplier<String> stringSupplier = () ->"OK";
   // 使用方法引用提供 Supplier 接口实现，返回空字符串
   Supplier<String> supplier = String::new;

   方法引用是 Lambda 表达式的另一种表现形式

   Lambda 表达式可用方法引用代替的场景：Lambda 表达式的主体仅包含一个表达式，且该表达式仅调用了一个已经存在的方法

   方法引用可以是：

   • 类 : : 静态方法
   • 类 : : new
   • 类 : : 实例方法（(A, B) -> A.实例方法(B) <=> A 的类 : : 实例方法）
   • 任意对象 : : 实例方法

创建 Stream

1. 利用 stream 方法将 list 或数组转换为流

   Arrays.asList("a1", "a2", "a3").stream().forEach(System.out::println);
   Arrays.stream(new int[]{1, 2, 3}).forEach(System.out::println);

   非基本数据类型的数值也可以使用 Arrays.asList 方法转 list 再调 stream

2. 通过 Stream.of 方法直接传入多个元素构成一个流

   String[] arr = {"a", "b", "c"};
   Stream.of(arr).forEach(System.out::println);
   Stream.of("a", "b", "c").forEach(System.out::println);
   Stream.of(1, 2, "a").map(item -> item.getClass().getName())
       .forEach(System.out::println);

3. 通过 Stream.iterate 方法使用迭代的方式构造一个无限流，然后使用 limit 限制流元素个数

   Stream.iterate(2, item -> item * 2).limit(10).forEach(System.out::println);
   Stream.iterate(BigInteger.ZERO, n -> n.add(BigInteger.TEN))
       .limit(10).forEach(System.out::println);

4. 通过 Stream.generate 方法从外部传入一个提供元素的 Supplier 来构造无限流，再使用 limit 限制流元素个数

   Stream.generate(() -> "test").limit(3).forEach(System.out::println);
   Stream.generate(Math::rando