明天要讲的 Stream 指的是 java.util.stream 包中的诸多类。Stream 能够不便的将之前的联合类以转换为 Stream 并以流式形式进行解决，大大的简化了咱们的编程，Stream 包中，最外围的就是 interface Stream<T>

从下面的图中咱们能够看到 Stream 继承自 BaseStream。Stream 中定义了很多十分实用的办法，比方 filter，map，flatmap,forEach,reduce,collect 等等。接下来咱们将会逐个解说。

创立 Stream

Stream 的创立有很多形式，java 引入 Stream 之后所有的汇合类都增加了一个 stream() 办法，通过这个办法能够间接失去其对应的 Stream。也能够通过 Stream.of 办法来创立：

//Stream Creation
        String[] arr = new String[]{"a", "b", "c"};
        Stream<String> stream = Arrays.stream(arr);
        stream = Stream.of("a", "b", "c");

Streams 多线程

如果咱们想应用多线程来解决汇合类的数据，Stream 提供了十分不便的多线程办法 parallelStream()：

//Multi-threading
        List<String> list =new ArrayList();
        list.add("aaa");
        list.add("bbb");
        list.add("abc");
        list.add("ccc");
        list.add("ddd");
        list.parallelStream().forEach(element -> doPrint(element));

Stream 的基本操作

Stream 的操作能够分为两类，一类是两头操作，两头操作返回 Stream<T>，因而能够级联调用。另一类是终止操作，这类操作会返回 Stream 定义的类型。

//Operations
        long count = list.stream().distinct().count();

下面的例子中，distinct() 返回一个 Stream，所以能够级联操作，最初的 count() 是一个终止操作，返回最初的值。

Matching

Stream 提供了 anyMatch(), allMatch(), noneMatch() 这三种 match 形式，咱们看下怎么应用：

//Matching
        boolean isValid = list.stream().anyMatch(element -> element.contains("h"));
        boolean isValidOne = list.stream().allMatch(element -> element.contains("h"));
        boolean isValidTwo = list.stream().noneMatch(element -> element.contains("h")); 

Filtering

filter() 办法容许咱们对 Stream 中的数据进行过滤，从而失去咱们须要的：

Stream<String> filterStream = list.stream().filter(element -> element.contains("d"));

下面的例子中咱们从 list 中选出了蕴含“d”字母的 String。

Mapping

map 就是对 Stream 中的值进行再加工，而后将加工过后的值作为新的 Stream 返回。

//Mapping
        Stream<String> mappingStream = list.stream().map(element -> convertElement(element));

    private static String convertElement(String element) {return "element"+"abc";}

上的例子中咱们把 list 中的每个值都加上了“abc”而后返回一个新的 Stream。

FlatMap

flatMap 和 Map 很相似，然而他们两个又有不同，看名字咱们能够看到 flatMap 意思是打平之后再做 Map。

怎么了解呢？

如果咱们有一个 CustBook 类：

@Data
public class CustBook {List<String> bookName;}

CustBook 定义了一个 bookName 字段。

先看一下 Map 返回的后果：

List<CustBook> users = new ArrayList<>();
        users.add(new CustBook());
Stream<Stream<String>> userStreamMap
                = users.stream().map(user -> user.getBookName().stream());

在下面的代码中，map 将每一个 user 都转换成了 stream，所以最初的后果是返回 Stream 的 Stream。

如果咱们只想返回 String，则能够应用 FlatMap：

List<CustBook> users = new ArrayList<>();
        users.add(new CustBook());
        Stream<String> userStream
                = users.stream().map(user -> user.getBookName().stream());

简略点讲 FlatMap 就是将层级关系铺平重来。

Reduction

应用 reduce() 办法能够不便的对汇合的数据进行运算，reduce() 接管两个参数，第一个是开始值，前面是一个函数示意累计。

//Reduction
        List<Integer> integers = Arrays.asList(1, 1, 1);
        Integer reduced = integers.stream().reduce(100, (a, b) -> a + b);

下面的例子咱们定义了 3 个 1 的 list，而后调用 reduce(100, (a, b) -> a + b) 办法，最初的后果是 103.

Collecting

collect() 办法能够不便的将 Stream 再次转换为汇合类，不便解决和展现：

List<String> resultList
                = list.stream().map(element -> element.toUpperCase()).collect(Collectors.toList());