Stream 是 java8 中處理集合的抽象概念，可以執(zhí)行非常復雜的查詢、過濾和映射數據等操作。Stream API 提供了一種高效的處理數據方式，Stream 對集合數據的操作可以說是非常的方便。Stream 是流，不是一種數據結構，也不會保存數據，只是一種數據處理方式，從一種數據組織結構到另外一種數據結構。

2 Stream 的分類

按照 Stream 的，可以分為以下集中方式：

1 中間操作無狀態(tài)，指元素的處理不受之前元素的影響。
2 中間操作有狀態(tài)，等到獲取所有元素之后才能繼續(xù)進行處理。
3 最終操作非短路操作，必須處理所有元素后才能得到最終結果。
4 最終操作短路操作，當遇到符合條件的元素就可以拿到最終結果。

3 Stream 的操作

3.1 創(chuàng)建流的方式

關于流的創(chuàng)建方式，可以使用數組或者集合，流的形式分為順序流和并行流。

具體如下所示：

// 數組形式獲取流
String[] dataArrs = new String[10];
Stream<String> stream = Arrays.stream(dataArrs);
// 集合方式創(chuàng)建
List<String> dataList = new ArrayList<>();
// 獲取一個順序流
Stream<String> stream = dataList.stream();
 // 獲取一個并行流
Stream<String> parallelStream = dataList.parallelStream();

當然處理上述的形式之外，也可以使用 Stream 的內置方法 generate()、of()、iterate() 來創(chuàng)建。

// of 創(chuàng)建 stream
Stream<String> strs = Stream.of("a","b","c","d");
// lambda 創(chuàng)建等差數列，獲取前 3 個
Stream<Integer> stream2 = Stream.iterate(1, (x) -> x + 4).limit(3);
stream2.forEach(System.out::println); // 1 5 9
// 隨機獲取三個隨機數
Stream<Double> stream3 = Stream.generate(Math::random).limit(3);
stream3.forEach(System.out::println);

3.2 流的中間操作

關于流的中間操作，主要分為以下幾種：

1 篩選操作與切片， filter 過濾流中的某些元素，limit 獲取某幾個元素，skip 跳過某些元素，通常和 limit 配合使用實現分頁操作。distinct 通常用來實現去重操作。
2 映射操作， map 和 flatmap , 兩者都是接受一個函數為函數，前者是映射到一個元素，后者則是將一個元素映射成一個流。
3 排序操作，這里就很好理解，就是 sorted 操作。

Stream<String> strs = Stream.of("a","b","c","d","d","e","f");
// 過濾大于b 的字符串并進行去重操作，跳過前兩個并選取兩個進行輸出
Stream<String> result = strs.filter(s -> s.compareTo("b") > 0)
                .distinct()
                .skip(2)
                .limit(2);
// 輸出結果 e 和 f
result.forEach(System.out::println);
// flatMap 的操作
List<String> list = Arrays.asList("e,f,g", "1,2,3");
// 利用map去除每個元素中的逗號
Stream<String> st1 = list.stream().map(s -> s.replaceAll(",", ""));
st1.forEach(System.out::println); // efg  123
// 利用 flatMap 將字符串進行分割
Stream<String> st2 = list.stream().flatMap(ele -> {
    //將每個元素轉換成一個stream
    String[] split = ele.split(",");
    return Arrays.stream(split);
});
st2.forEach(System.out::println); // e f g 1 2 3
// 排序操作
List<String> list = Arrays.asList("aa", "ff", "dd");
//String 類自身已實現Compareable接口 aa dd ff
list.stream().sorted().forEach(System.out::println);

3.3 流的終止操作

1 stream 匹配和聚合操作。匹配相關的 allMatch、noneMatch、anyMatch 三者都是接受一個 Predicate 函數，當每個元素都滿足、都不滿足、只要有一個元素滿足,并返回斷言結果。統計相關，count、sum、 max 、min 。findFirst 和 findAny 為查找第一個或者任意一個元素進行返回。
2 規(guī)約操作， reduce ，這是一個不太好理解的概念，從數學角度來說，reduce 接受的是一個函數是一個推導式，類似于 a_j = a_i + 1, j = i+1aj?=ai?+1,j=i+1
3 收集操作，即 collect，當所有的數據都處理完畢后，需要將數據進行處理，通常而言，獲取的結果就是 set 、list 或者 map。

// match 操作 findFirst  findAny  count max min 操作
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
// 返回結果 false
boolean allMatch = list.stream().allMatch(e -> e > 10);
// 返回結果 true
boolean noneMatch = list.stream().noneMatch(e -> e > 10);
// 返回結果 true
boolean anyMatch = list.stream().anyMatch(e -> e > 4);
// 查找第一個或者隨機獲取
Integer findFirst = list.stream().findFirst().get();
Integer findAny = list.stream().findAny().get();
// 統計數據 個數為 5 最大值為 5 最小值為 1
long count = list.stream().count();
Integer max = list.stream().max(Integer::compareTo).get();
Integer min = list.stream().min(Integer::compareTo).get();
// reduce 操作
List<Integer> list = Arrays.asList(1, 2, 3);
// 該操作即是 累加求和，結果為 6
Integer result = list.stream().reduce((x1, x2) -> x1 + x2).get();
System.out.println(result);
// 標簽
List<String> tags1 = Lists.newArrayList("a", "b", "c");
List<String> tags2 = Lists.newArrayList("d", "e", "f");
// 創(chuàng)建對象
User user1 = new User("小明", 12, tags1, BigDecimal.valueOf(43));
User user2 = new User("小李", 14, tags2, BigDecimal.valueOf(43));
// 聲明數組對象
List<User> userList = Lists.newArrayList(user1, user2);
// 年齡和體重數據
List<Integer> ageList = userList.stream().map(User::getAge).collect(Collectors.toList());
Set<BigDecimal> weightSet = userList.stream().map(User::getWeight).collect(Collectors.toSet());
// 建立姓名年齡映射
Map<String, Integer> nameAgeMap = userList.stream().collect(Collectors.toMap(User::getName,User::getAge, (k1, k2) -> k2));
// flatMap 獲取所有的標簽
List<String> tagsList = userList.stream().flatMap(node -> node.getTags().stream().map(String::intern)).distinct().collect(Collectors.toList());
// 按照年齡分組
Map<Integer, List<User>> ageMap = userList.stream().collect(Collectors.groupingBy(User::getAge));
// 分區(qū)分成兩部分，一部分大于10歲，一部分小于等于10歲
Map<Boolean, List<User>> partMap = userList.stream().collect(Collectors.partitioningBy(v -> v.getAge() > 10));
//規(guī)約 reduce
Integer sumAge = userList.stream().map(User::getAge).collect(Collectors.reducing(Integer::sum)).get();