一、前言
之前淺談Stream的collect()操作，就與Collector相關，這也是與Stream同時新創的介面，官方文件一開頭又提到
mutable reduction operation
A mutable reduction operation that accumulates input elements into a mutable result container, optionally transforming the accumulated result into a final representation after all input elements have been processed. Reduction operations can be performed either sequentially or in parallel.
簡單的說，擁有組合函數(combining function)、資料結構(data structure)或某些情況下有預設值、初始值，進行一系列組合拳，可以依照順序出拳，也可以同時出拳的華麗操作。
目錄
- 一、前言
-
二、Collectors
- (2.1) Collectors.toCollection()
- (2.2) Collectors.toList()
- (2.3) Collectors.toUnmodifiableList()
- (2.4) Collectors.toSet()
- (2.5) Collectors.toUnmodifiableSet()
- (2.6) Collectors.toMap()
- (2.7) Collectors.toUnmodifiableMap()
- (2.8) Collectors.joining()
- (2.9) Collectors.counting()
- (2.10) Collectors.collectingAndThen()
- (2.11) Collectors.summarizingDouble/Long/Int()
- (2.12) Collectors.averagingDouble/Long/Int()
- (2.13) Collectors.summingDouble/Long/Int()
- (2.14) Collectors.maxBy/minBy()
- (2.15) Collectors.groupingBy()
- (2.16) Collectors.partitioningBy()
- (2.17) Collectors.teeing()
- (2.18) Collectors.filtering()
- (2.19) Collectors.mapping()
- (2.20) Collectors.flatMapping()
- 三、自定義Collector
- 四、總結
二、Collectors
Collectors 是 JDK 中的實用程式類之一，它包含許多實用程式函數。它主要作為最後一步與 Stream API 一起使用。該類別是stream套件中的一部分，可以這樣導入
xxxxxxxxxx1
import static java.util.stream.Collectors.*;2
除此之外，我們可以選擇單一類別導入
xxxxxxxxxx1
import static java.util.stream.Collectors.toList;2
import static java.util.stream.Collectors.toMap;3
import static java.util.stream.Collectors.toSet;4
(2.1) Collectors.toCollection()
如果我們想使用自定義實現，則需要使用toCollection()收集器以及我們選擇的提供的集合。
範例：創建一個 Stream 實例，然後將它們收集到 LinkedList 實例中
xxxxxxxxxx1
public class Collectors17 {2
public static void main(String[] args) {3
toCollection();4
}5
6
public static void toCollection() {7
List<Integer> result = Stream.iterate(1, x -> x + 2).limit(4)8
.collect(Collectors.toCollection(LinkedList::new));9
result.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 Collectors17.java && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\java Collectors172
13
34
55
76
(2.2) Collectors.toList()
範例：創建一個 Stream 實例，然後將它們收集到 List 中
xxxxxxxxxx1
public class Collectors17 {2
public static void main(String[] args) {3
toList();4
}5
public static void toList() {6
List<Integer> result = Stream.iterate(0, x -> x + 2).limit(4)7
.collect(Collectors.toList());8
result.forEach(System.out::println);9
}10
}11
輸出結果：
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 Collectors17.java && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\java Collectors172
03
24
45
66
(2.3) Collectors.toUnmodifiableList()
Java 10 引入了一種將 Stream 元素累積到不可修改的 List 中的便捷方法：
xxxxxxxxxx1
public class Collectors17 {2
public static void main(String[] args) {3
toUnmodifiableList();4
}5
public static void toUnmodifiableList(){6
List<Integer> result = Stream.iterate(0, x -> x + 1).limit(4)7
.collect(Collectors.toUnmodifiableList());8
result.forEach(System.out::println);9
// throw by UnsupportedOperationException10
result.add(11);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 Collectors17.java && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\java Collectors172
03
14
25
36
Exception in thread "main" java.lang.UnsupportedOperationException7
at java.base/java.util.ImmutableCollections.uoe(ImmutableCollections.java:142)8
at java.base/java.util.ImmutableCollections$AbstractImmutableCollection.add(ImmutableCollections.java:147)9
at Collectors17.toUnmodifiableList(Collectors17.java:27)10
at Collectors17.main(Collectors17.java:8)11
(2.4) Collectors.toSet()
toSet() 收集器可用於收集 Set 實例中的所有 Stream 元素。
xxxxxxxxxx1
public class Collectors17 {2
public static void main(String[] args) {3
toSet();4
}5
public static void toSet() {6
Set<Integer> result = Arrays.asList(1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5).stream()7
.collect(Collectors.toSet());8
result.forEach(System.out::println);9
}10
}11
輸出結果：
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 Collectors17.java && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\java Collectors172
13
24
35
46
57
(2.5) Collectors.toUnmodifiableSet()
從 Java 10 開始，我們可以使用 toUnmodifiableSet（） 收集器輕鬆創建不可修改的 Set：
xxxxxxxxxx1
public class Collectors17 {2
public static void main(String[] args) {3
toUnmodifiableSet();4
}5
public static void toUnmodifiableSet() {6
Set<Integer> result = Arrays.asList(1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5).stream()7
.collect(Collectors.toUnmodifiableSet());8
result.forEach(System.out::println);9
// throw by UnsupportedOperationException10
result.add(11);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 Collectors17.java && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\java Collectors172
23
34
45
56
17
Exception in thread "main" java.lang.UnsupportedOperationException8
at java.base/java.util.ImmutableCollections.uoe(ImmutableCollections.java:142)9
at java.base/java.util.ImmutableCollections$AbstractImmutableCollection.add(ImmutableCollections.java:147)10
at Collectors17.toUnmodifiableSet(Collectors17.java:44)11
at Collectors17.main(Collectors17.java:10)12
(2.6) Collectors.toMap()
toMap() 收集器可用於將 Stream 元素收集到 Map 實例中。為此，我們需要提供兩個函數：keyMapper() 和 valueMapper()。
首先，我們將使用keyMapper() 從 Stream 元素中提取 Map 鍵。 然後，我們可以使用 valueMapper() 來提取與給定鍵關聯的值。
範例：將這些元素收集到一個 Map 中，該 Map 將字串存儲為鍵，將其長度存儲為值：
xxxxxxxxxx1
public class Collectors17 {2
public static void main(String[] args) {3
toMap1();4
}5
public static void toMap1() {6
Map<String, Integer> result = Arrays.asList("a", "bb", "c", "d").stream()7
.collect(Collectors.toMap(Function.identity(), String::length));8
result.forEach((x, y) -> System.out.println("key=" + x + ", value=" + y));9
}10
}11
輸出結果：
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 Collectors17.java && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\java Collectors172
key=bb, value=23
key=a, value=14
key=c, value=15
key=d, value=16
那麼，如果我們的集合包含重複的元素會發生什麼呢？與 toSet() 相反，toMap() 方法不會靜默過濾重複項，這是可以理解的，因為它如何確定要為此鍵選擇哪個值？
請注意，toMap() 甚至不評估值是否也相等。如果它看到重複的鍵，它會立即引發 IllegalStateException。
xxxxxxxxxx1
public class Collectors17 {2
public static void main(String[] args) {3
toMap2();4
}5
public static void toMap2() {6
Map<String, Integer> result = Arrays.asList("a", "bb", "c", "d", "bb").stream()7
.collect(Collectors.toMap(Function.identity(), String::length));8
result.forEach((x, y) -> System.out.println("key=" + x + ", value=" + y));9
}10
}11
輸出結果：
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 Collectors17.java && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\java Collectors172
Exception in thread "main" java.lang.IllegalStateException: Duplicate key bb (attempted merging values 2 and 2)3
at java.base/java.util.stream.Collectors.duplicateKeyException(Collectors.java:135)4
at java.base/java.util.stream.Collectors.lambda$uniqKeysMapAccumulator$1(Collectors.java:182)5
at java.base/java.util.stream.ReduceOps$3ReducingSink.accept(ReduceOps.java:169)6
at java.base/java.util.Spliterators$ArraySpliterator.forEachRemaining(Spliterators.java:992)7
at java.base/java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:509)8
at java.base/java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:499)9
at java.base/java.util.stream.ReduceOps$ReduceOp.evaluateSequential(ReduceOps.java:921)10
at java.base/java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:234)11
at java.base/java.util.stream.ReferencePipeline.collect(ReferencePipeline.java:682)12
at Collectors17.toMap(Collectors17.java:51)13
at Collectors17.main(Collectors17.java:12)14
在這種情況下，如果發生密鑰衝突，我們應該使用帶有另一個簽名的 toMap()：
xxxxxxxxxx1
public class Collectors17 {2
public static void main(String[] args) {3
toMap3();4
}5
public static void toMap3() {6
Map<String, Integer> result = Arrays.asList("a", "bb", "c", "d", "bb").stream()7
.collect(Collectors.toMap(Function.identity(), String::length, (item, identicalItem) -> item));8
result.forEach((x, y) -> System.out.println("key=" + x + ", value=" + y));9
}10
}11
輸出結果：
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 Collectors17.java && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\java Collectors172
key=bb, value=23
key=a, value=14
key=c, value=15
key=d, value=16
(2.7) Collectors.toUnmodifiableMap()
與 List和 Set類似，Java 10 引入了一種將 Stream 元素收集到不可修改的 Map 中的簡單方法：
xxxxxxxxxx1
public class Collectors17 {2
public static void main(String[] args) {3
toUnmodifiableMap();4
}5
public static void toUnmodifiableMap() {6
Map<String, Integer> result = Arrays.asList("a", "bb", "c", "d").stream()7
.collect(Collectors.toUnmodifiableMap(Function.identity(), String::length));8
result.forEach((x, y) -> System.out.println("key=" + x + ", value=" + y));9
// throw by UnsupportedOperationException10
result.put("ccc", 3);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 Collectors17.java && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\java Collectors172
key=bb, value=23
key=d, value=14
key=c, value=15
key=a, value=16
Exception in thread "main" java.lang.UnsupportedOperationException7
at java.base/java.util.ImmutableCollections.uoe(ImmutableCollections.java:142)8
at java.base/java.util.ImmutableCollections$AbstractImmutableMap.put(ImmutableCollections.java:1072)9
at Collectors17.toUnmodifiableMap(Collectors17.java:72)10
at Collectors17.main(Collectors17.java:12)11
(2.8) Collectors.joining()
joining() 可用於連接 Stream
範例：將元素串接起來
xxxxxxxxxx1
public class Collectors17 {2
public static void main(String[] args) {3
joining1();4
}5
public static void joining1() {6
String result = Arrays.asList("a", "bb", "c", "d", "bb").stream()7
.collect(Collectors.joining());8
System.out.println(result);9
}10
}11
輸出結果：
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 Collectors17.java && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\java Collectors172
abbcdbb3
我們還可以指定自定義分隔符、前綴和後綴：
xxxxxxxxxx1
public class Collectors17 {2
public static void main(String[] args) {3
joining2();4
}5
public static void joining2() {6
String result = Arrays.asList("a", "bb", "c", "d", "bb").stream()7
.collect(Collectors.joining(";", "PRE-", "-POST"));8
System.out.println(result);9
}10
}11
輸出結果：
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 Collectors17.java && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\java Collectors172
PRE-a;bb;c;d;bb-POST3
(2.9) Collectors.counting()
counting() 是一個簡單的收集器，允許對所有 Stream 元素進行計數。
xxxxxxxxxx1
public class Collectors17 {2
public static void main(String[] args) {3
counting();4
}5
public static void counting() {6
long result = Arrays.asList("a", "bb", "c", "d", "bb").stream()7
.collect(Collectors.counting());8
System.out.println(result);9
}10
}11
輸出結果：
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 Collectors17.java && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\java Collectors172
53
(2.10) Collectors.collectingAndThen()
CollectingAndThen() 是一個特殊的收集器，它允許我們在收集結束后立即對結果執行另一個操作。
範例：計算各個元素出現的比例
collectingAndThen 的第一個參數是 count() 來取得頻率。
然後您可以透過將其轉換為格式化百分比來處理該頻率。
xxxxxxxxxx1
public class Collectors17 {2
public static void main(String[] args) {3
collectingAndThen();4
}5
public static void collectingAndThen() {6
List<String> input = List.of("FOO", "FOO", "FOO", "FOO", "FOO", "BAR",7
"BAR", "BAZ", "BAZ", "BAZ", "DOO", "DOO");8
Map<String, String> map = input.stream().collect(Collectors9
.groupingBy(a -> a, Collectors.collectingAndThen(10
Collectors.counting(),11
count -> "%.2f%%".formatted((double) count12
/ input.size() * 100))));13
map.entrySet().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 Collectors17.java && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\java Collectors172
BAR=16.67%3
DOO=16.67%4
FOO=41.67%5
BAZ=25.00%6
(2.11) Collectors.summarizingDouble/Long/Int()
SummarizingDouble/Long/Int 是一個收集器，它返回一個特殊類，其中包含有關提取元素 Stream 中數值數據的統計資訊。
範例：獲取字串長度的資訊
xxxxxxxxxx1
public class Collectors17 {2
public static void main(String[] args) {3
summarizingDouble();4
}5
public static void summarizingDouble() {6
DoubleSummaryStatistics result = Arrays.asList("a", "bb", "ccc", "dd").stream()7
.collect(Collectors.summarizingDouble(String::length));8
System.out.println(result);9
}10
}11
輸出結果：
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 Collectors17.java && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\java Collectors172
DoubleSummaryStatistics{count=4, sum=8.000000, min=1.000000, average=2.000000, max=3.000000}3
(2.12) Collectors.averagingDouble/Long/Int()
AveragingDouble/Long/Int 是一個收集器，它只返回提取元素的平均值。
範例：獲得平均字串長度
xxxxxxxxxx1
public class Collectors17 {2
public static void main(String[] args) {3
averagingDouble();4
}5
public static void averagingDouble() {6
Double result = Arrays.asList("a", "bb", "ccc", "dd").stream()7
.collect(Collectors.averagingDouble(String::length));8
System.out.println(result);9
}10
}11
輸出結果：
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 Collectors17.java && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\java Collectors172
2.03
(2.13) Collectors.summingDouble/Long/Int()
SummingDouble/Long/Int 是一個收集器，它只返回提取的元素的總和。
範例：獲取所有字串長度的總和
xxxxxxxxxx1
public class Collectors17 {2
public static void main(String[] args) {3
summingDouble();4
}5
public static void summingDouble() {6
Double result = Arrays.asList("a", "bb", "ccc", "dd").stream()7
.collect(Collectors.summingDouble(String::length));8
System.out.println(result);9
}10
}11
輸出結果：
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 Collectors17.java && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\java Collectors172
8.03
(2.14) Collectors.maxBy/minBy()
MaxBy 和 MinBy 收集器根據提供的 Comparator 實例返回 Stream 的最大/最小元素。
範例：選擇最大的元素
xxxxxxxxxx1
public class Collectors17 {2
public static void main(String[] args) {3
maxBy();4
}5
public static void maxBy() {6
Optional<String> result = Arrays.asList("a", "bb", "ccc", "dd").stream()7
.collect(Collectors.maxBy(Comparator.naturalOrder()));8
System.out.println(result);9
System.out.println(result.get());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 Collectors17.java && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\java Collectors172
Optional[dd]3
dd4
(2.15) Collectors.groupingBy()
通常，我們可以使用 GroupingBy() 收集器按給定屬性對對象進行分組，然後將結果存儲在 Map 實例中。
範例：按字串長度對它們進行分組，並將分組結果存儲在 Set 實例中
xxxxxxxxxx1
public class Collectors17 {2
public static void main(String[] args) {3
groupingBy();4
}5
public static void groupingBy() {6
Map<Integer, Set<String>> result = Arrays.asList("a", "bb", "ccc", "dd").stream()7
.collect(Collectors.groupingBy(String::length, Collectors.toSet()));8
System.out.println(result);9
result.forEach((key, value) -> System.out.println(key + ":" + value));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 Collectors17.java && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\java Collectors172
{1=[a], 2=[bb, dd], 3=[ccc]}3
1:[a]4
2:[bb, dd]5
3:[ccc]6
(2.16) Collectors.partitioningBy()
partitioningBy() 是 groupingBy() 的一個特殊情況，它接受一個 Predicate 實例，然後將 Stream 元素收集到 Map 實例中，該實例將布林值存儲為鍵，將集合存儲為值。在 「true」 鍵下，我們可以找到與給定 Predicate 匹配的元素集合，在 「false」 鍵下，我們可以找到與給定 Predicate 不匹配的元素集合。
範例：按字串長度 是否大於2 對它們進行分組，並將分組結果存儲在 Set 實例中
xxxxxxxxxx1
public class Collectors17 {2
public static void main(String[] args) {3
partitioningBy();4
}5
public static void partitioningBy() {6
Map<Boolean, List<String>> result = Arrays.asList("a", "bb", "ccc", "dd").stream()7
.collect(Collectors.partitioningBy(s->s.length()>2));8
System.out.println(result);9
result.forEach((key, value) -> System.out.println(key + ":" + value));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 Collectors17.java && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\java Collectors172
{false=[a, bb, dd], true=[ccc]}3
false:[a, bb, dd]4
true:[ccc]5
(2.17) Collectors.teeing()
Java 12 提供了一個內置的收集器，使用兩個不同的收集器，然後將這兩個收集器的結果結合起來，創建一些有意義的東西。
由於這個新的收集器將給定的流向兩個不同的方向發球，因此稱為 teeing()。
xxxxxxxxxx1
static <T,R1,R2,R> Collector<T,?,R>2
teeing(Collector<? super T,?,R1> downstream1, Collector<? super T,?,R2> downstream2, BiFunction<? super R1,? super R2,R> merger)3
4
* downstream1 - the first downstream collector5
* downstream2 - the second downstream collector6
* merger - the function which merges two results into the single one7
* returns - a Collector which aggregates the results of two supplied colle8
範例：計算最小與最大值相加結果
xxxxxxxxxx1
public class Collectors17 {2
public static void main(String[] args) {3
teeing();4
}5
public static void teeing() {6
Integer result = Arrays.asList(2, 48, 56, 32, 8, 11, 26, -9, 22, 19).stream()7
.collect(Collectors.teeing(Collectors.minBy(Integer::compareTo), Collectors.maxBy(Integer::compareTo),8
(a, b) -> a.get() + b.get()));9
10
System.out.println(result);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 Collectors17.java && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\java Collectors172
473
(2.18) Collectors.filtering()
Collectors.filtering() 類似於 Stream.filter()。它用於篩選輸入元素，但用於不同的方案。Stream API 中的 filter() 方法用於流鏈中，而這個新的 filtering() 方法是一個收集器，可以與 groupingBy() 一起使用。
使用 filter() 時，首先過濾值，然後對其進行分組。這樣，被過濾掉的值就消失了，沒有它的痕跡。如果我們需要跟蹤，那麼我們需要先分組，然後應用過濾。
範例：提取集合中值大於3的元素
xxxxxxxxxx1
public class Collectors17 {2
public static void main(String[] args) {3
filtering();4
}5
public static void filtering() {6
List<Integer> result = List.of(1, 2, 3, 5, 5).stream()7
.filter(n -> n > 3)8
.collect(Collectors.toList());9
System.out.println(result);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 Collectors17.java && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\java Collectors172
[5, 5]3
(2.19) Collectors.mapping()
該方法是一個downstream收集器，它將函數應用於流中的每個元素，然後收集轉換后的元素。
xxxxxxxxxx1
static <T,U,A,R> Collector<T,?,R>2
mapping(Function<? super T,? extends U> mapper, Collector<? super U,A,R> downstream)3
4
* mapper：將 type T 的元素轉換為 type U 的函數。5
* downstream：用於累積轉換元素的收集器。6
範例：將元素轉為大寫再使用
-
串接起來
xxxxxxxxxx1
public class Collectors17 {2
public static void main(String[] args) {3
mapping();4
}5
public static void mapping() {6
List<String> input = List.of("Apple", "Banana", "Apricot", "Atemoya",7
"Avocados", "Blueberry", "Blackcurrant", "Ackee",8
"Cranberry", "Cantaloupe", "Cherry");9
String result = input.stream().collect(Collectors.mapping(String::toUpperCase, Collectors.joining("-")));10
System.out.println(result);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 Collectors17.java && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\java Collectors172
APPLE-BANANA-APRICOT-ATEMOYA-AVOCADOS-BLUEBERRY-BLACKCURRANT-ACKEE-CRANBERRY-CANTALOUPE-CHERRY3
(2.20) Collectors.flatMapping()
Collectors.flatMapping() 類似於 Collectors.mapping()，但具有更細粒度的目標。兩個收集器都接受一個函數和一個收集器，其中元素被收集，但 flatMapping() 函數接受一個元素流，然後由收集器累積。
Collectors.flatMapping() 允許我們跳過中間集合，直接寫入映射到 Collectors.groupingBy() 定義的組的單個容器。
Collectors.mapping() 將所有分組作者的評論映射到收集器的容器，即 List，而這個中間集合被 flatMapping() 刪除，因為它提供了要映射到收集器容器的評論清單的直接流。
xxxxxxxxxx1
public class Collectors17 {2
public static void main(String[] args) {3
flatMapping();4
}5
public static void flatMapping() {6
Blog blog1 = new Blog("1", "Nice", "Very Nice");7
Blog blog2 = new Blog("1", "Good", "Very Good");8
Blog blog3 = new Blog("2", "Disappointing", "Ok", "Could be better");9
List<Blog> blogs = List.of(blog1, blog2, blog3);10
Map<String, List<List<String>>> authorComments1 = blogs.stream()11
.collect(Collectors.groupingBy(Blog::getAuthorName,12
Collectors.mapping(Blog::getComments, Collectors.toList())));13
System.out.println(authorComments1);14
15
Map<String, List<String>> authorComments2 = blogs.stream()16
.collect(Collectors.groupingBy(Blog::getAuthorName,17
Collectors.flatMapping(blog -> blog.getComments().stream(),18
Collectors.toList())));19
System.out.println(authorComments2);20
}21
static class Blog {22
private String authorName;23
private List<String> comments;24
25
public Blog(String authorName, String... strComments) {26
this.authorName = authorName;27
this.comments = Arrays.asList(strComments);28
}29
30
public String getAuthorName() {31
return authorName;32
}33
34
public void setAuthorName(String authorName) {35
this.authorName = authorName;36
}37
38
public List<String> getComments() {39
return comments;40
}41
42
public void setComments(List<String> comments) {43
this.comments = comments;44
}45
}46
}47
輸出結果：
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 Collectors17.java && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\java Collectors172
{1=[[Nice, Very Nice], [Good, Very Good]], 2=[[Disappointing, Ok, Could be better]]}3
{1=[Nice, Very Nice, Good, Very Good], 2=[Disappointing, Ok, Could be better]}4
三、自定義Collector
Collector介面定義了一組方法，用於收集、轉換和匯總數據，這使得我們能夠從流中收集到特定的數據結構，如List、Set、Map等，或執行複雜的聚合操作，如分組、分區、規約總結等。
Collector介面包含以下五個主要方法：
- supplier(): 建立新的結果容器，可以是一個容器，也可以是一個累加器實例，總之是用來儲存結果資料的
- accumlator(): 元素進入收集器中的具體處理操作
- finisher(): 當所有元素都處理完成後，在返回結果之前的對結果的最終處理操作，當然也可以選擇不做任何處理，直接返回
- combiner(): 各個子流的處理結果最終如何合併到一起去，例如並行流處理場景，元素會被切分為好多個分片進行並行處理，最終各個分片的數據需要合併為一個整體結果，即通過此方法來指定子結果的合併邏輯
-
characteristics(): 對此收集器處理行為的補充描述，比如此收集器是否允許並行流中處理，是否finisher方法必須要有等等，此處返回一個Set集合，裡面的候選值是固定的幾個可選項。
- UNORDERED 聲明此收集器的總歸約結果與Stream流元素遍歷順序無關，不受元素處理順序影響
- CONCURRENT 聲明此收集器可以多個執行緒並行處理，允許在並行流中進行處理
- IDENTITY_FINISH 聲明此收集器的finisher方法是恆等操作，可以跳過
範例：將Person物件進行排序，並根據特定條件進行分組。
xxxxxxxxxx1
public class Collectors17 {2
public static void main(String[] args) {3
custCollector();4
}5
public static class Person {6
String name;7
Integer age;8
9
Person(String name, Integer age) {10
this.name = name;11
this.age = age;12
}13
14
15
public String toString() {16
return "Person [name=" + name + ", age=" + age + "]";17
}18
}19
20
public static class MyCustomCollector<T> implements Collector<Person, List<Person>, Map<String, List<Person>>> {21
22
public Supplier<List<Person>> supplier() {23
return ArrayList::new;24
}25
26
27
public BiConsumer<List<Person>, Person> accumulator() {28
return (list, person) -> list.add(person);29
}30
31
32
public BinaryOperator<List<Person>> combiner() {33
return (list1, list2) -> {34
list1.addAll(list2);35
return list1;36
};37
}38
39
40
public Function<List<Person>, Map<String, List<Person>>> finisher() {41
return list -> {42
Map<String, List<Person>> result = new HashMap<>();43
44
list.sort((p1, p2) -> {45
if (p1.age != null && p2.age != null) {46
return p1.age.compareTo(p2.age);47
} else if (p1.age != null) {48
return -1;49
} else if (p2.age != null) {50
return 1;51
} else {52
return p1.name.compareTo(p2.name);53
}54
});55
56
for (Person person : list) {57
if (result.containsKey(person.name)) {58
result.get(person.name).add(person);59
} else {60
List<Person> group = new ArrayList<>();61
group.add(person);62
result.put(person.name, group);63
}64
}65
66
return result;67
};68
}69
70
71
public Set<Collector.Characteristics> characteristics() {72
// return EnumSet.of(Collector.Characteristics.UNORDERED);73
return Collections.emptySet();74
}75
}76
77
public static void custCollector() {78
List<Person> people = Arrays.asList(79
new Person("A", 28),80
new Person("B", null),81
new Person("C", 27),82
new Person("D", 22),83
new Person("A", 25),84
new Person("B", 24),85
new Person("B", 21));86
Map<String, List<Person>> result = people.stream().collect(new MyCustomCollector<>());87
System.out.println(result);88
}89
}90
輸出結果：
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 Collectors17.java && D:\jdk\zulu17.54.21-ca-jdk17.0.13-win_x64\bin\java Collectors172
{A=[Person [name=A, age=25], Person [name=A, age=28]], B=[Person [name=B, age=21], Person [name=B, age=24], Person [name=B, age=null]], C=[Person [name=C, age=27]], D=[Person [name=D, age=22]]}3
建立了一個自訂的Collector，用於對Person物件進行排序和分組。排序規則是基於年齡和姓名的組合，分組規則是基於姓名。
困難在於實作finisher()方法，該方法需要按照自訂的排序和分組規則處理結果容器。在排序過程中，我們考慮了年齡和姓名的組合，確保排序的正確性。在分組過程中，我們根據姓名進行分組，形成最終的分組結果。
四、總結
Java Stream API 中提供 collect() 方法，透過Collector介面來完成自定義數據收集、轉換和聚合的過程。通過實現Collector介面，我們可以根據自己的需求創建特定的收集器，從而滿足複雜的數據處理需求。
Collectors類別是已經實現Collector介面，提供超多實用的方法讓我們可以針對常用的集合(Set、Map、List)使用流的方式處理，實現完美的遷移，進入流的世界。
沒有留言:
張貼留言