一、概述

在Java8中有两个最为重要的改变。第一个是Lambda表达式，另一个便是StreamAPI。
它真正将函数式编程风格引入到Java中。这是目前为止对Java类库最好的补充，因为其可以极大地提高Java程序员的生产力。
Stream是Java8中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据的操作。使用StreamAPI来并行执行操作，就类似于使用SQL执行数据库查询。也可以使用StreamAPI来并行执行操作。简而言之，它提供了一种高效且易于使用的处理数据的方式。

二、为什么使用StreamAPI

实际开发中，项目中多数数据源都来自于Mysql，Oracle等。但现在数据源可以更多了，有MongDB，Radis等，而这些NoSQL的数据就需要Java层面去处理。
Stream 和 Collection 集合的区别：Collection 是一种静态的内存数据结构，而 Stream 是有关计算的。前者是主要面向内存，存储在内存中，后者主要是面向 CPU，通过 CPU 实现计算。三、什么是Stream
它是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。（“集合讲的是数据，Stream讲的是计算！”）

注意： 1.Stream不会存储元素； 2.Stream不会改变源对象。相反，它会返回一个特有结果的新的Stream。 3.Stream操作是延迟执行的。这意味着他们会等到需要结果的时候再去执行

四、Stream的操作步骤

1.创建

从一个数据源（如集合、数组），获取一个流

方式一:通过集合

Java8中Collection接口被扩展，提供了两个获取流的方法：

default Stream<E> stream() : 返回一个顺序流
default Stream<E> parallelStream() : 返回一个并行流

测试

    public void m1(){
        String[] arr = {"Java","C","C++","php","python","Mysql","vb"};
        List<String> list = Arrays.asList(arr);
//        default Stream<E> stream() : 返回一个顺序流
        Stream<String> stream = list.stream();
//        default Stream<E> parallelStream() : 返回一个并行流(像多线程一样，顺序就不定了)
        Stream<String> stringStream = list.parallelStream();
    }

方式二:通过数组

Java8 中的 Arrays 的静态方法 stream() 可以获取数组流：

static <T> Stream<T> stream(T[] array): 返回一个流
重载形式，能够处理对应基本类型的数组：
public static IntStream stream(int[] array)
public static LongStream stream(long[] array)
public static DoubleStream stream(double[] array)

测试

    public void m2(){
//        基本数据类型Stream流
        int[] arr = {1,5,4,5,5};
        IntStream stream = Arrays.stream(arr);
//        引用数据类型Stream流
        String[] arr1 = {"Java","C","C++","php","python","Mysql","vb"};
        Stream<String> stream1 = Arrays.stream(arr1);
        double[] arr3 = {1,1.1,1.11,1.111};
        DoubleStream stream2 = Arrays.stream(arr3);
//        基本数据类型的Stream流靠类名区分，引用数据类型的Stream流靠泛型区分
    }

方式三:通过Stream的of()

可以调用Stream类静态方法 of(), 通过显示值创建一个流。它可以接收任意数量的参数。

public static<T> Stream<T> of(T... values) : 返回一个流

测试

    public void m3(){
        Stream stream = Stream.of("b", "a", "cc", "fad",new Person1());
    }

方式四:创建无限流

可以使用静态方法 Stream.iterate() 和 Stream.generate(),创建无限流。

迭代
public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)
生成
public static<T> Stream<T> generate(Supplier<T> s)

测试

    public void m4(){
//        迭代
//        public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)
        Stream<String> s = Stream.iterate("", t -> t + "java");//初始值为""，后面对“java的累加”
        s.limit(5).forEach(System.out::println);//限制个数为5
//        生成
//        public static<T> Stream<T> generate(Supplier<T> s)
        Stream<Double> s1 = Stream.generate(Math::random);//获取无限随机数
        s1.limit(5).forEach(System.out::println);//限制个数为5
    }

结果

2.中间操作

一个中间的操作链，对数据源的数据进行处理多个中间操作可以连接起来像一个流水线一般，除非流水线上出发了终止操作，否则中间操作不会执行任何的处理！而在终止操作时会一次性全部处理，称为“惰性求值”。

筛选与切片

方法	描述
filter(Predicate p)	接收Lembda，从流中排出一些特定特征的元素
distinct()	筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素
limit(long maxSize)	截断流，使其元素不超过给定数量
skip(long n)	跳过前 n 个元素。若元素不足 n 个，则返回一个空流。与 limit(n) 互补

测试

    public void m5() {
        //生成流
        Stream<Integer> s1 = Stream.of(1, 2, 5, 8, 9, 6, 1, 4, 5, 2, 3, 5, 6,
                1, 5, 5, 6, 8, 5, 9, 8, 5, 8, 7, 4, 2, 1,
                3, 6, 5, 8, 5, 4, 1, 2, 5, 8, 9, 6, 3, 2,
                1, 4, 5, 2, 5, 2, 1, 5, 4, 2, 8, 5, 7, 4);
        //只留下奇数
        s1.filter((value) -> value % 2 != 0).
//                //去重
                        distinct().
//                //截断 取前4个
                        limit(4).
//                //跳过3个元素
                        skip(3).
//                //遍历
                forEach(System.out::println);
    }

映射

测试

    public void m6() {
        Stream<String> s1 = Stream.of("Java", "C", "C++", "php", "python", "Mysql", "vb");
        //每个元素都进行指定的操作
//        s1.map(String :: toUpperCase).forEach(System.out::println);
        //取得每个元素的长度，变成IntStream
//        s1.mapToInt(String::length).forEach(System.out::println);
        //将初始流中所有元素打开 在生成新的流
//        s1.flatMap(t->Stream.of(t.split(""))).forEach(System.out::println);
        //把初始流中所有元素进行替换成123(如果加进来的元素多个  会被打散   区别于map)
        s1.flatMap(t->Stream.of("123","12")).forEach(System.out::println);
    }

排序

测试

public void m7() {
        Stream<String> s1 = Stream.of("Java", "C", "C++", "php", "python", "Mysql", "vb");
        //自然排序
//        s1.sorted().forEach(System.out::println);
        //定制排序
        s1.sorted((o1, o2) -> o1.length() - o2.length()).forEach(System.out::println);
    }

结果

3.终止操作

一旦执行终止操作，就会执行中间操作链，并产生结果。之后Stream不再被使用。

匹配与查找

测试

    public void m8() {
        String[] strings ={"Java", "C", "C++", "php", "python", "Mysql", "vb"};
        Stream<String> s1 = Arrays.asList(strings).parallelStream();
//        Stream<String> s1 = Stream.of("Java", "C", "C++", "php", "python", "Mysql", "vb");
//        allMatch(Predicate p) 检查是否匹配所有元素
//        System.out.println(s1.allMatch(s -> s.length() >= 1));//true

//        anyMatch(Predicate p) 检查是否至少匹配一个元素
//        System.out.println(s1.anyMatch(s -> s.length() >= 7));//false

//        noneMatch(Predicate p) 检查是否没有匹配所有元素
//        System.out.println(s1.noneMatch(s -> s.endsWith("12")));//全部不满足 返回true

//        findFirst() 返回第一个元素
//        System.out.println(s1.findFirst());

//        findAny() 返回当前流中的任意元素(得是并行流)
//        System.out.println(s1.findAny());

//        count() 返回流中元素总数
//        System.out.println(s1.count());

//        max(Comparator c) 返回流中最大值
//        System.out.println(s1.max((s, s2) -> s.length() - s2.length()));

//        min(Comparator c) 返回流中最小值
//        System.out.println(s1.min((s, s2) -> s.length() - s2.length()));

//        forEach(Consumer c)
        s1.forEach(System.out::println);
    }

归约

备注：map 和 reduce 的连接通常称为 map-reduce 模式，因 Google用它来进行网络搜索而出名

测试

    public void m9() {
        Stream<Integer> s = Stream.of(1, 2, 3, 4, 5, 4, 3, 2, 1);
//        System.out.println(s.reduce(0, Integer::sum));//求和 //有初始值的

        System.out.println(s.reduce(Integer::sum));//无初始值
    }

收集

Collector 接口中方法的实现决定了如何对流执行收集的操作(如收集到 List、Set、 Map)。另外， Collectors 实用类提供了很多静态方法，可以方便地创建常见收集器实例，具体方法与实例如下表：

五、补充 Optional 类

为了解决空指针异常，Google公司著名的Guava项目引入了Optional类，Guava通过使用检查空值的方式来防止代码污染，它鼓励程序员写更干净的代码。受到Google Guava的启发，Optional类已经成为Java 8类库的一部分。
Optional 类(java.util.Optional) 是一个容器类，它可以保存类型T的值，代表这个值存在。或者仅仅保存null，表示这个值不存在。原来用 null 表示一个值不存在，现在 Optional 可以更好的表达这个概念。并且可以避免空指针异常。
Optional类的Javadoc描述如下：这是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。
Optional提供很多有用的方法，这样我们就不用显式进行空值检测。
- 创建Optional 类对象的方法：
  - Optional.of(T t) : 创建一个 Optional 实例，t必须非空；
  - Optional.empty() : 创建一个空的 Optional 实例
  - Optional.ofNullable(T t) ：t可以为null
- 判断Optional 容器中是否包含对象：
  - boolean isPresent() : 判断是否包含对象
  - void ifPresent(Consumer<? super T> consumer) ：如果有值，就执行Consumer接口的实现代码，并且该值会作为参数传给它。
- 获取Optional 容器的对象：
  - T get(): 如果调用对象包含值，返回该值，否则抛异常
  - T orElse(T other) ：如果有值则将其返回，否则返回指定的other对象。
  - T orElseGet(Supplier<? extends T> other) ：：如果有值则将其返回，否则返回由
- Supplier接口实现提供的对象。
  - T orElseThrow(Supplier<? extends X> exceptionSupplier) ：：如果有值则将其返回，否则抛出由Supplier接口实现提供的异常。

Java8新特性之强大的StreamAPI