前面兩篇簡單的介紹了Stream以及如何創建Stream，本篇就給大家說說stream有哪些用途，以及具體怎樣使用。
再次介紹Stream
Stream 使用一種類似用於SQL 語句從數據庫查詢數據的直觀方式來提供一種對 Java 集合運算和表達的高階抽象。 Stream API可以極大提高Java程序員的生產力，讓程序員寫出高效率、干凈、簡潔的代碼。 這種風格將要處理的元素集合看作一種流，流在管道中傳輸，並且可以在管道的節點上進行處理，比如篩選，排序，聚合等。
Stream兩種操作
- 中間操作（Intermediate Operations）：中間操作會返回一個新的流，一個流可以后面跟隨零個或多個intermediate操作。其目的主要是打開流，做出某種程度的數據映射/過濾，然后會返回一個新的流，交給下一個操作使用。這類操作都是惰性化的（lazy），就是說，僅僅調用到這類方法，並沒有真正開始流的遍歷。而是在終端操作開始的時候才真正開始執行。
- 終端操作（Terminal Operations）：是指返回最終的結果。一個流只能有一個terminal操作，當這個操作執行后，流就被使用“光”了，無法再被操作。所以這必定是流的最后一個操作。Terminal操作的執行，才會真正開始流的遍歷，並且會生成一個結果，或者一個 side effect。
中間操作方法分類：
- filter()
- map()
- flatMap()
- distinct()
- sorted()
- peek()
- limit()
- skip()
終端操作方法分類：
- forEach()
- forEachOrdered()
- toArray()
- reduce()
- collect()
- min()
- max()
- count()
- anyMatch()
- allMatch()
- noneMatch()
- findFirst()
- findAny()
中間操作代碼實例詳解
1、filter(): 返回結果生成新的流中只包含滿足篩選條件的數據。
// 1、filter,返回大於2的元素集合
List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> result = nums.stream().filter(n -> n > 2).collect(Collectors.toList());
System.out.println(result);
運行結果：[3, 4, 5]
2、map():將流中的元素進行再次加工形成一個新流，流中的每一個元素映射為另外的元素。
// 2、map：返回元素的大寫類型和哈希值
List<String> mzc = Arrays.asList("ma", "zhi", "chu");
List<String> mzcUpperCase = mzc.stream().
map(n -> n.toUpperCase()).
collect(Collectors.toList());
List<Integer> mzcHashCode = mzc.stream().map(n -> n.hashCode()).collect(Collectors.toList());
System.out.println("mzcUpperCase:"+mzcUpperCase+" ----- mzcHashCode:"+mzcHashCode);
運行結果：
mzcUpperCase:[MA, ZHI, CHU] ----- mzcHashCode:[3476, 120571, 98480]
示例場景：取出商品的所有id，就可以這樣寫（偽代碼）：
List<Product> productList = productService.selectAll();
List<Integer> pIds = productList.stream().map(p->p.getId).collect(Collectors.toList())；
這樣就可以拿到所有商品id的集合。
3、flatMap()：扁平化映射，它具體的操作是將多個stream連接成一個stream，這個操作是針對類似多維數組的，比如集合里面包含集合，相當於降維作用。
flatMap是將流中的每個元素都放到一個流中，最后將所有的流合並成一個新流，所有流對象中的元素都合並到這個新生成的流中返回。
// flatMap:將多層集合中的元素取出來，放到一個新的集合中去
List<Integer> num1 = Arrays.asList(1, 2, 3);
List<Integer> num2 = Arrays.asList(4, 5, 6);
List<Integer> num3 = Arrays.asList(7, 8, 9);
List<List<Integer>> lists = Arrays.asList(num1, num2, num3);
Stream<Integer> outputStream = lists.stream().flatMap(l -> l.stream());
List<Integer> flatMapResult = outputStream.sorted().collect(Collectors.toList());
System.out.println(flatMapResult);
運行結果：[1, 2, 3, 4, 5, 6, 7, 8, 9]
示例場景：取出所有部門人員的姓名，就可以這樣寫（偽代碼）：
// 1、取出所有部門
List<Department> departments = ...;
// 2、這個時候可以利用flatMap先將所有部門的所有人員匯聚起來
List<Person> persons = departments.stream.flatMap(d->d.getPersonList()).collect(Collectors.toList())；
// 3、再利用map()方法取出
4、distinct()：顧名思義，將流中的元素去重之后輸出。
List<String> mzc = Stream.of("ma","zhi","chu","zhi","shuo","ma")
.distinct()
.collect(Collectors.toList());
System.out.println(mzc);
運行結果：[ma, zhi, chu, shuo]
5、sorted()：這個很簡單了，顧名思義，將流中的元素按照自然排序方式進行排序。
// sorted:自然順序排序
List<Integer> nums = Arrays.asList(1, 3, 5, 6, 8, 2);
List<Integer> sortedNum = nums.stream().sorted().collect(Collectors.toList());
System.out.println(sortedNum);
// sorted:降序排序
List<Integer> sortedNum2 = nums.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList());
System.out.println(sortedNum2);
// sorted:使用Comparator
List<Integer> sortedNums3 = nums.stream().sorted(Comparator.comparing(n -> n)).collect(Collectors.toList());
System.out.println(sortedNums3);
// 不用stream直接順序排序
nums.sort(Comparator.comparing(Integer::intValue));
System.out.println(nums);
//不用stream直接降序排序
nums.sort(Comparator.comparing(Integer::intValue).reversed());
System.out.println(nums);
運行結果：
[1, 2, 3, 5, 6, 8]
[8, 6, 5, 3, 2, 1]
[1, 2, 3, 5, 6, 8]
[1, 2, 3, 5, 6, 8]
[8, 6, 5, 3, 2, 1]
6、peek()：對流中每個元素執行操作，並返回一個新的流，返回的流還是包含原來流中的元素。
// peek()：
String[] arr = new String[]{"a","b","c","d"};
Arrays.stream(arr)
.peek(System.out::println) //a,b,c,d
.count();
// peek()+filter()
Stream.of("ma", "zhi", "chu")
.filter(e -> e.length() > 2)
.peek(e -> System.out.println(e))
.collect(Collectors.toList());
運行結果：
a
b
c
d
zhi
chu
7、limit()：顧名思義，返回指定數量的元素的流。返回的是Stream里前面的n個元素。
// limit()：取出100中的前十個
List<Integer> limitNum = IntStream.range(1,100).limit(10)
.boxed()
.collect(Collectors.toList());
System.out.println(limitNum);
// limit():取出前4個單詞
List<String> words = Arrays.asList("ma", "zhi", "chu", "wait", "you", "follow");
List<String> limitWord = words.stream().limit(4).collect(Collectors.toList());
System.out.println(limitWord);
運行結果：
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[ma, zhi, chu, wait]
8、skip()：和limit()相反，將前幾個元素跳過（取出）再返回一個流，如果流中的元素小於或者等於n，就會返回一個空的流。
// skip():跳過前面三個單詞再返回
List<String> words = Arrays.asList("ma", "zhi", "chu", "wait", "you", "follow");
List<String> skipWord = words.stream().limit(4).collect(Collectors.toList());
System.out.println(skipWord);
// skip():跳過全部單詞再返回
List<String> emptyWord = words.stream().skip(6).collect(Collectors.toList());
System.out.println(emptyWord);
// skip():跳過超過單詞長度的數目再返回
List<String> emptyWord2 = words.stream().skip(10).collect(Collectors.toList());
System.out.println(emptyWord);
運行結果：
[91, 92, 93, 94, 95, 96, 97, 98, 99]
[ma, zhi, chu, wait]
[]
[]
上面講了Stream流中間操作的使用詳解，希望能給大家帶來幫助，如果有用，還麻煩點個在看，或者分享給需要的小伙伴，獨樂樂不如眾樂樂，謝謝！
因為考慮篇幅太長，大家看起來可能會有點累，所以Stream的終端操作使用詳解，串行化、並行化區別，以及stream流總結放到后面的文章中。如果你還想了解更多其他方面的知識，歡迎留言鼓勵，我會爭取越寫越好，越寫越全面。