一、前言
Java團隊規劃函數化Lambda操作，讓Java物件導向的語言更簡潔，操作起來很有函數的風格。可是在引入Lambda的概念前，Java可是純物件導向，那些根深蒂固的物件要如何改造才能相容以前的寫法，又可以重生使用函數化操作呢？
規劃流水線，使用建造者模式(Builder Design Pattern)的概念，一個函數，一個功能，慢慢完成最終的成品。
新建立函數化風格的套件- java.util.stream ，在這個套件內的所有Class都是支持函數化操作。
Classes to support functional-style operations on streams of elements, such as map-reduce transformations on collections.
目錄
二、Stream串流
該規劃最關鍵的抽象概念是
stream
(流)。可以通過Stream、IntStream、LongStream、DoubleStream讓物件(Objects)與基本型別(primitive type)進入
stream
的操作中。
- No storage：流不是儲存元素的資料結構；而是儲存元素的資料結構。相反，它透過計算操作的管道傳送來自資料結構、陣列、生成器函數或 I/O 通道等來源的元素。
- Functional in nature：對流的操作會產生結果，但不會修改其來源。例如，過濾從集合中取得的 a 會產生一個沒有過濾元素的新元素，而不是從來源集合中刪除元素。
- Laziness-seeking：許多串流操作（例如過濾、映射或重複刪除）可以延遲實現，從而提供最佳化的機會。例如，「尋找第一個具有三個連續母音的」不需要檢查所有輸入字串。流操作分為中間（產生）操作和終端（產生值value-producing或side-effect-producing）操作。中間運算總是Lazy。
- Possibly unbounded：雖然集合的大小是有限的，但流則不需要。諸如 limit(n) 或 findFirst() 之類的Short-circuiting operations可以允許在有限時間內在無限流上計算完成。
- Consumable：在流的生命週期中，流的元素只被存取一次。與迭代器一樣，必須產生新流才能重新訪問來源中的相同元素。
可以從以下這些方式獲取流Streams：
-
Collection透過stream()和parallelStream()方法獲取。 -
陣列透過
Arrays.stream(Object[]);方法獲得。 -
檔案的行數透過
BufferedReader.lines();方法獲得。 -
檔案流透過
Files的方法find、list、walk等方法獲得。 -
亂數流可透過
Random.ints();方法獲得。 -
在java.util.stream套件包下物件的靜態方法也可以獲得，如
Stream.of(Object[]),IntStream.range(int, int)orStream.iterate(Object, UnaryOperator);等靜態方法獲得。
流的操作分為
intermediate
轉換管道(如:filter())和
terminal
終止管道(如：forEach())，組合進
pipelines
管線流中。轉換管道不會立即取得結果，而是會執行處理後放入一個新創建的Stream再返回給您；終止管道則是一個Consumer，管線流到這邊就結束不再能使用。
Intermediate Operations
| API | 功能說明 |
|---|---|
| filter() | 依照條件過濾符合要求的元素，傳回新的streamflowmap()將已有元素轉換為另一個物件類型，重複一邏輯，傳回新的stream |
| flatMap() | 將已有元素轉換為另一個對象類型，原來多邏輯，即一個元素物件可以轉換為1個或多個新類型的元素，傳回新的stream |
| limit() | 只保留集合前面指定的個數的元素，新的stream流 |
| skip() | 跳過集合前面指定的個數的元素，傳回新的stream流 |
| concat() | 將兩個流的資料合併為1個新的流，傳回新的stream流 |
| distinct() | 對Stream中所有元素進行重整，傳回新的stream流 |
| sorted() | 將stream中所有元素依照指定規則排序，傳回新的stream流 |
| peek() | 對stream流中的每個元素進行逐一遍歷處理，返回處理後的stream |
Terminal Operations
| API | 功能說明 |
|---|---|
| count() | 返回stream處理後最終的元素個數 |
| max() | 返回stream處理後的元素最大值 |
| min() | 返回stream處理後的元素最小值 |
| findFirst() | 找到第一個符合條件的元素時則終止流處理 |
| findAny() | 找到任何一個符合條件的元素時則退出流處理，此對於串行流時與findFirst相同，對於單個流時高效比較，任何分片中找到終止後續計算邏輯 |
| anyMatch() | 返回一個boolean值，相似isContains(),用來判斷是否符合條件的元素 |
| allMatch() | 傳回一個boolean值，用於判斷所有元素是否都符合條件 |
| noneMatch() | 傳回一個boolean值，用於判斷是否所有元素不符合條件 |
| collect() | 將流轉換為指定的類型，透過Collectors進行指定toArray()將流轉換為Arrayiterator() |
三、串流的操作
- Intermediate: map (mapToInt, flatMap, etc.), filter, distinct, sorted, peek, limit, skip, parallel, sequential, unordered
- Terminal: forEach, forEachOrdered, toArray, reduce, collect, min, max, count, anyMatch, allMatch, noneMatch, findFirst, findAny, iterator
- Short-circuiting: anyMatch, allMatch, noneMatch, findFirst, findAny, limit Let’s take a look at the more typical uses of Stream.
我們來看看Stream的比較典型的用法
(3.1) forEach
對此流的每個元素執行一個操作。
xxxxxxxxxx1
void forEach(Consumer<? super T> action)2
範例：輸出集合中所有元素
xxxxxxxxxx1
public class Stream17 {2
public static void main(String[] args) {3
forEach();4
}5
public static void forEach() {6
// Creating a list of Integers7
List<Integer> list = Arrays.asList(3, 6, 9, 12, 15);8
9
// displaying the corresponding new stream10
list.stream().forEach(System.out::println);11
}12
}13
輸出結果：
xxxxxxxxxx1
[Running] cd "d:\Ethan\workspace\lab\example\text\java-newfeatures\src\" && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\javac Stream17.java && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\java Stream172
33
64
95
126
157
(3.2) map
Stream map(Function mapper)傳回一個流，其中包含將給定函數應用於該流的元素的結果。
Stream map(Function Mapper)是一個 intermediate operation。這些操作總是lazy。中間操作在 Stream 實例上調用，在完成處理後，它們提供 Stream 實例作為輸出。
xxxxxxxxxx1
<R> Stream<R> map(Function<? super T, ? extends R> mapper)2
3
where, R is the element type of the new stream.4
Stream is an interface and T is the type of stream elements. mapper is a stateless function which is applied to each element and the function returns the new stream.5
範例：將集合中的數字乘以3
xxxxxxxxxx1
public class Stream17 {2
public static void main(String[] args) {3
map();4
}5
public static void map() {6
System.out.println("The stream after applying "7
+ "the function is : ");8
9
// Creating a list of Integers10
List<Integer> list = Arrays.asList(3, 6, 9, 12, 15);11
12
// Using Stream map(Function mapper) and13
// displaying the corresponding new stream14
list.stream().map(number -> number * 3).forEach(System.out::println);15
}16
}17
輸出結果：
xxxxxxxxxx1
[Running] cd "d:\Ethan\workspace\lab\example\text\java-newfeatures\src\" && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\javac Stream17.java && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\java Stream172
The stream after applying the function is : 3
94
185
276
367
458
(3.3) flatMap
Stream flatMap(Function mapper)傳回一個流，其中包含將此流的每個元素替換為通過將提供的映射函數應用於每個元素而生成的映射流的內容的結果。是一個 intermediate operation。
flatMap（） v.s. map（） 的調用：
- map（） 將流的每個元素轉換為另一個對象，從而生成與輸入大小相同的流。它用於一對一轉換。
- flatMap（） 將流的每個元素轉換為零個或多個元素，從而可能會改變流的大小。它用於一對多轉換和扁平化嵌套結構。
xxxxxxxxxx1
<R> Stream<R> flatMap(Function<? super T,? extends Stream<? extends R>> mapper)2
範例：將集合扁平化輸出
xxxxxxxxxx1
public class Stream17 {2
public static void main(String[] args) {3
map();4
}5
public static void flapMap() {6
// Creating a List of Lists7
List<List<String>> listOfLists = Arrays.asList(8
Arrays.asList("Geeks", "For"),9
Arrays.asList("GeeksForGeeks", "A computer portal"),10
Arrays.asList("Java", "Programming"));11
12
// Using Stream flatMap(Function mapper)13
listOfLists.stream()14
.flatMap(list -> list.stream())15
.forEach(System.out::println);16
}17
}18
輸出結果：
xxxxxxxxxx1
[Running] cd "d:\Ethan\workspace\lab\example\text\java-newfeatures\src\" && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\javac Stream17.java && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\java Stream172
Geeks3
For4
GeeksForGeeks5
A computer portal6
Java7
Programming8
(3.4) filter
Stream filter(Predicate predicate)傳回一個流，該流由此流中與給定Predicate匹配的元素組成。這是一個intermediate operation。 這些操作始終是lazy，即執行諸如 filter() 之類的中間操作實際上並不執行任何過濾，而是創建一個新流，該流在遍歷時包含與給定predicate匹配的初始流的元素。
xxxxxxxxxx1
Stream<T> filter(Predicate<? super T> predicate)2
範例：從集合中篩選出被5整除的數字
xxxxxxxxxx1
public class Stream17 {2
public static void main(String[] args) {3
filter();4
}5
public static void filter() {6
// Creating a list of Integers7
List<Integer> list = Arrays.asList(3, 4, 6, 12, 20);8
9
// Getting a stream consisting of the10
// elements that are divisible by 511
// Using Stream filter(Predicate predicate)12
list.stream()13
.filter(num -> num % 5 == 0)14
.forEach(System.out::println);15
}16
}17
輸出結果：
xxxxxxxxxx1
[Running] cd "d:\Ethan\workspace\lab\example\text\java-newfeatures\src\" && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\javac Stream17.java && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\java Stream172
203
(3.5) findFirst
Stream findFirst（） 傳回描述此流的第一個元素的 Optional（容器物件，可能包含也可能不包含非 null 值），如果流為空，則返回空的 Optional。如果流沒有遭遇順序，則可以返回任何元素。
xxxxxxxxxx1
Optional<T> findFirst()2
3
Where, Optional is a container object which4
may or may not contain a non-null value and T is the type of objects and the function returns an Optional describing the first element of this stream, or an empty Optional if the stream is empty.5
範例：回傳集合中第一個元素
xxxxxxxxxx1
public class Stream17 {2
public static void main(String[] args) {3
findFirst();4
}5
public static void findFirst() {6
// Creating a List of Integers 7
List<Integer> list = Arrays.asList(3, 5, 7, 9, 11);8
9
// Using Stream findFirst() 10
Optional<Integer> answer = list.stream().findFirst();11
12
// if the stream is empty, an empty 13
// Optional is returned. 14
if (answer.isPresent()) {15
System.out.println(answer.get());16
} else {17
System.out.println("no value");18
}19
}20
}21
輸出結果：
xxxxxxxxxx1
[Running] cd "d:\Ethan\workspace\lab\example\text\java-newfeatures\src\" && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\javac Stream17.java && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\java Stream172
33
(3.6) reduce
Stream.reduce() 方法用於使用關聯累加函數對流的元素執行縮減，並返回一個Optional。它通常用於將元素聚合或組合成單個結果，例如計算最大值、最小值、總和或乘積。
xxxxxxxxxx1
T reduce(T identity, BinaryOperator<T> accumulator);2
3
identity: An initial value of type .T4
accumulator: A function that combines two values of type .T5
範例1：串接字串
xxxxxxxxxx1
public class Stream17 {2
public static void main(String[] args) {3
reduce1();4
}5
public static void reduce1() {6
// String array to combine7
String[] array = { "Fork", "for", "Ford" };8
9
// Using reduce to concatenate strings with a hyphen10
Optional<String> combinedString = Arrays.stream(array)11
.reduce((str1, str2) -> str1 + "-" + str2);12
13
// Displaying the combined String14
combinedString.ifPresent(System.out::println);15
}16
}17
輸出結果：
xxxxxxxxxx1
[Running] cd "d:\Ethan\workspace\lab\example\text\java-newfeatures\src\" && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\javac Stream17.java && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\java Stream172
Fork-for-Ford3
範例2：將數字相乘
xxxxxxxxxx1
public class Stream17 {2
public static void main(String[] args) {3
reduce2();4
}5
public static void reduce2() {6
// Calculating the product of all numbers in the range [2, 8)7
int product = IntStream.range(2, 8)8
.reduce((num1, num2) -> num1 * num2)9
.orElse(-1); // Provides -1 if the stream is empty10
11
// Displaying the product12
System.out.println("The product is : " + product);13
}14
}15
輸出結果：
xxxxxxxxxx1
[Running] cd "d:\Ethan\workspace\lab\example\text\java-newfeatures\src\" && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\javac Stream17.java && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\java Stream172
The product is : 50403
(3.7) limit
Stream.limit(long maxSize) 的方法將maxSize作為參數，並返回大小不超過 maxSize 的流。如果 maxSize 的值很大，則 limit() 在有序並行管道上可能會效能消費很高，因為 limit(long maxSize) 被限制返回按順序返回前 maxSize 個元素。
xxxxxxxxxx1
Stream<T> limit(long maxSize)2
Where maxSize is the number of elements the stream should be limited to and this function returns new stream as output.3
範例：限制集合長度為3
xxxxxxxxxx1
public class Stream17 {2
public static void main(String[] args) {3
limit();4
}5
public static void limit() {6
// list to save stream of strings7
List<String> arr = new ArrayList<>();8
9
arr.add("geeks");10
arr.add("for");11
arr.add("geeks");12
arr.add("computer");13
arr.add("science");14
15
Stream<String> str = arr.stream();16
17
// calling function to limit the stream to range 318
Stream<String> lm = str.limit(3);19
lm.forEach(System.out::println);20
}21
}22
輸出結果：
xxxxxxxxxx1
[Running] cd "d:\Ethan\workspace\lab\example\text\java-newfeatures\src\" && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\javac Stream17.java && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\java Stream172
geeks3
for4
geeks5
(3.8) skip
在丟棄流的前 n 個元素後，返回由該流的剩餘元素組成的流。
xxxxxxxxxx1
Stream<T> skip(long n)2
範例：輸出偶數，但跳過前2個
xxxxxxxxxx1
public class Stream17 {2
public static void main(String[] args) {3
skip();4
}5
public static void skip() {6
Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)7
.filter(i -> i % 2 == 0)8
.skip(2)9
.forEach(i -> System.out.print(i + " "));10
}11
}12
輸出結果：
xxxxxxxxxx1
[Running] cd "d:\Ethan\workspace\lab\example\text\java-newfeatures\src\" && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\javac Stream17.java && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\java Stream172
6 8 10 3
(3.9) sorted
Stream sorted() 傳回一個由此 stream 的元素組成的 stream，根據自然 Sequences 排序。對於有序流，排序方法是穩定的，但對於無序流，不能保證穩定性。它是一個有狀態的中間操作，即，在處理新元素時，它可能會合併以前看到的元素的狀態。
xxxxxxxxxx1
Stream<T> sorted()2
3
Where, Stream is an interface and T is the type of stream elements.4
範例：對集合中數字作自然排序
xxxxxxxxxx1
public class Stream17 {2
public static void main(String[] args) {3
sorted();4
}5
public static void sorted() {6
// Creating a list of integers 7
List<Integer> list = Arrays.asList(-9, -18, 0, 25, 4);8
9
System.out.println("The sorted stream is : ");10
11
// displaying the stream with elements 12
// sorted in natural order 13
list.stream().sorted().forEach(System.out::println);14
}15
}16
輸出結果：
xxxxxxxxxx1
[Running] cd "d:\Ethan\workspace\lab\example\text\java-newfeatures\src\" && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\javac Stream17.java && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\java Stream172
The sorted stream is : 3
-184
-95
06
47
258
(3.10) max/min
Stream.max() 根據提供的 Comparator 傳回 stream 的最大元素。Comparator 是一個比較函數，它對某些物件集合施加總排序。max() 是一個終端操作，它組合了 stream 元素並返回一個 summary 結果。所以， max() 是 reduction 的一個特例。該方法返回 Optional 實例。
xxxxxxxxxx1
Optional<T> max(Comparator<? super T> comparator)2
Stream.min() 則為傳回 stream 的最小元素。
xxxxxxxxxx1
Optional<T> min(Comparator<? super T> comparator)2
範例：取得集合內最大與最小值
xxxxxxxxxx1
public class Stream17 {2
public static void main(String[] args) {3
maxmin();4
}5
public static void maxmin() {6
// Creating a list of integers 7
List<Integer> list = Arrays.asList(-9, -18, 0, 25, 4);8
9
// Using stream.max() to get maximum 10
// element according to provided Comparator 11
// and storing in variable var 12
Integer var = list.stream().max(Integer::compare).get();13
System.out.println("The maximum value is : " + var);14
15
// Using stream.min() to get minimum 16
var = list.stream().min(Integer::compare).get();17
System.out.println("The minimum value is : " + var);18
}19
}20
輸出結果：
xxxxxxxxxx1
[Running] cd "d:\Ethan\workspace\lab\example\text\java-newfeatures\src\" && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\javac Stream17.java && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\java Stream172
The maximum value is : 253
The minimum value is : -184
(3.11) distinct
distinct() 傳回一個由 Stream 中的不同元素組成的 Stream。distinct() 是 Stream 介面的方法。此方法使用 hashCode() 和 equals() 方法來獲取不同的元素。在有序流的情況下，不同元素的選擇是穩定的。但是，在無序流的情況下，不同元素的選擇不一定穩定，並且可能會發生變化。distinct() 執行stateful intermediate operation，即它在內部維護一些狀態以完成操作。
xxxxxxxxxx1
Stream<T> distinct()2
3
Where, Stream is an interface and the function returns a stream consisting of the distinct elements.4
範例：取得集合內不重複的元素
xxxxxxxxxx1
public class Stream17 {2
public static void main(String[] args) {3
distinct();4
}5
public static void distinct() {6
// Creating a list of integers 7
List<Integer> list = Arrays.asList(1, 1, 2, 5, 3, 3, 5, 5);8
9
System.out.println("The distinct elements are :");10
11
// Displaying the distinct elements in the list 12
// using Stream.distinct() method 13
list.stream().distinct().forEach(System.out::println);14
}15
}16
輸出結果：
xxxxxxxxxx1
[Running] cd "d:\Ethan\workspace\lab\example\text\java-newfeatures\src\" && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\javac Stream17.java && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\java Stream172
The distinct elements are :3
14
25
56
37
(3.12) match
- Stream allMatch（Predicate predicate） Stream 中全部元素符合指定的predicate，傳回 true。
- Stream anyMatch（Predicate predicate） Stream只要有一個符合指定predicate的元素，回傳 true。
- Stream noneMatch（Predicate predicate） Stream中沒有一個元素符合指定的predicate，回傳true。
如果不是確定結果所必需的，它可能不會對所有元素的predicate求值。這3個都是short-circuiting terminal operation。如果終端操作在具有無限輸入時可能在有限時間內終止，則它是short-circuiting。
xxxxxxxxxx1
boolean allMatch(Predicate<? super T> predicate)2
boolean anyMatch(Predicate<? super T> predicate)3
boolean noneMatch(Predicate<? super T> predicate)4
範例：在集合中判斷是否匹配所有符合、任一符合或都不符合計算條件
xxxxxxxxxx1
public class Stream17 {2
public static void main(String[] args) {3
match();4
}5
public static void match() {6
// Creating a list of Integers 7
List<Integer> list = Arrays.asList(3, 4, 6, 12, 20);8
9
// Stream allMatch(Predicate predicate) 10
boolean answer = list.stream().allMatch(n -> (n * (n + 1)) / 4 == 5);11
// Displaying the result 12
System.out.println(answer);13
14
// Stream anyMatch(Predicate predicate) 15
answer = list.stream().anyMatch(n -> (n * (n + 1)) / 4 == 5);16
// Displaying the result 17
System.out.println(answer);18
19
// Stream noneMatch(Predicate predicate) 20
answer = list.stream().noneMatch(n -> (n * (n + 1)) / 4 == 5);21
// Displaying the result 22
System.out.println(answer);23
}24
}25
輸出結果：
xxxxxxxxxx1
[Running] cd "d:\Ethan\workspace\lab\example\text\java-newfeatures\src\" && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\javac Stream17.java && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\java Stream172
false3
true4
false5
(3.13) generate
Stream generate（Supplier
xxxxxxxxxx1
static <T> Stream<T> generate(Supplier<T> s)2
3
Where, Stream is an interface and T is the type of stream elements.4
s is the Supplier of generated elements and the return value is a new infinite sequential unordered Stream.5
範例：隨機生成5個整數
xxxxxxxxxx1
public class Stream17 {2
public static void main(String[] args) {3
generate();4
}5
public static void generate() {6
// using Stream.generate() method 7
// to generate 5 random Integer values 8
Stream.generate(new Random()::nextInt)9
.limit(5).forEach(System.out::println);10
}11
}12
輸出結果：
xxxxxxxxxx1
[Running] cd "d:\Ethan\workspace\lab\example\text\java-newfeatures\src\" && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\javac Stream17.java && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\java Stream172
14169629703
-20919354334
-20322568815
-1044136346
8423418317
(3.14) iterate
iterate(T seed, Predicate<? super T> hasNext, UnaryOperator
如果傳遞的 predicate 不持有 seed 值，則此方法返回的結果序列可能為空。否則，第一個元素將是提供的種子值，下一個元素將是將 next 函數應用於種子值的結果，依此類推，直到 hasNext predicate 指示流應終止。
xxxxxxxxxx1
static <T> Stream<T> iterate(T seed, Predicate<? super T> hasNext, UnaryOperator<T> next)2
範例：
xxxxxxxxxx1
public class Stream17 {2
public static void main(String[] args) {3
iterate();4
}5
public static void iterate() {6
// create a stream using iterate 7
Stream<Integer> stream = Stream.iterate(1,8
i -> i <= 20, i -> i * 2);9
10
// print Values 11
stream.forEach(System.out::println);12
}13
}14
輸出範例：
xxxxxxxxxx1
[Running] cd "d:\Ethan\workspace\lab\example\text\java-newfeatures\src\" && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\javac Stream17.java && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\java Stream172
13
24
45
86
167
(3.14) collect
它允許我們對 Stream 實例中保存的數據元素執行mutable Fold(higher-order function) operations（將元素重新打包到一些數據結構並應用一些額外的邏輯、連接它們等）。
xxxxxxxxxx1
<R,A> R collect(Collector<? super T,A,R> collector)2
3
Interface Collector<T,A,R>4
Type Parameters:5
T - the type of input elements to the reduction operation6
A - the mutable accumulation type of the reduction operation (often hidden as an implementation detail)7
R - the result type of the reduction operation8
範例：將產生出的數字收集成List
xxxxxxxxxx1
public class Stream17 {2
public static void main(String[] args) {3
collect();4
}5
public static void collect() {6
// using Stream.generate() method 7
// to generate 5 random Integer values 8
// to collect to a list9
List<Integer> list = Stream.generate(new Random()::nextInt)10
.limit(5).collect(Collectors.toList());11
list.forEach(System.out::println);12
}13
}14
輸出結果：
xxxxxxxxxx1
[Running] cd "d:\Ethan\workspace\lab\example\text\java-newfeatures\src\" && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\javac Stream17.java && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\java Stream172
-9085046243
5111643294
-1384762655
-12132326506
3162745257
四、總結
我們大致上瞭解 Interface Stream 的操作方式，在 套件java.util.stream 中還有其他Stream，如：DoubleStream、IntStream、LongStream......等等，其操作方式和概念都是雷同的。
仍然還有許多概念並沒有提到很多，如
- Parallelism
- Side-effects
- Reduction operations
- Mutable reduction
- concurrency
- Associativity
引入Stream將改變集合生態，更是新增
Interface Collector<T,A,R>
等介面強化集合生態，優化、提升效能與簡化操作將是一大亮點。
沒有留言:
張貼留言