詳解Java8 Collect收集Stream的方法
Collection, Collections, collect, Collector, Collectos
Collection是Java集合的祖先接口。
Collections是java.util包下的一個工具類，內(nèi)涵各種處理集合的靜態(tài)方法。
java.util.stream.Stream#collect(java.util.stream.Collector<? super T,A,R>)是Stream的一個函數(shù)，負責收集流。
java.util.stream.Collector 是一個收集函數(shù)的接口, 聲明了一個收集器的功能。
java.util.Comparators則是一個收集器的工具類，內(nèi)置了一系列收集器實現(xiàn)。
收集器的作用
你可以把Java8的流看做花哨又懶惰的數(shù)據(jù)集迭代器。他們支持兩種類型的操作：中間操作(e.g. filter, map)和終端操作(如count, findFirst, forEach, reduce). 中間操作可以連接起來，將一個流轉(zhuǎn)換為另一個流。這些操作不會消耗流，其目的是建立一個流水線。與此相反，終端操作會消耗類，產(chǎn)生一個最終結(jié)果。collect就是一個歸約操作，就像reduce一樣可以接受各種做法作為參數(shù)，將流中的元素累積成一個匯總結(jié)果。具體的做法是通過定義新的Collector接口來定義的。
預(yù)定義的收集器
下面簡單演示基本的內(nèi)置收集器。模擬數(shù)據(jù)源如下：
final ArrayList<Dish> dishes = Lists.newArrayList(
new Dish("pork", false, 800, Type.MEAT),
new Dish("beef", false, 700, Type.MEAT),
new Dish("chicken", false, 400, Type.MEAT),
new Dish("french fries", true, 530, Type.OTHER),
new Dish("rice", true, 350, Type.OTHER),
new Dish("season fruit", true, 120, Type.OTHER),
new Dish("pizza", true, 550, Type.OTHER),
new Dish("prawns", false, 300, Type.FISH),
new Dish("salmon", false, 450, Type.FISH)
);
最大值，最小值，平均值
// 為啥返回Optional？ 如果stream為null怎么辦, 這時候Optinal就很有意義了 Optional<Dish> mostCalorieDish = dishes.stream().max(Comparator.comparingInt(Dish::getCalories)); Optional<Dish> minCalorieDish = dishes.stream().min(Comparator.comparingInt(Dish::getCalories)); Double avgCalories = dishes.stream().collect(Collectors.averagingInt(Dish::getCalories)); IntSummaryStatistics summaryStatistics = dishes.stream().collect(Collectors.summarizingInt(Dish::getCalories)); double average = summaryStatistics.getAverage(); long count = summaryStatistics.getCount(); int max = summaryStatistics.getMax(); int min = summaryStatistics.getMin(); long sum = summaryStatistics.getSum();
這幾個簡單的統(tǒng)計指標都有Collectors內(nèi)置的收集器函數(shù)，尤其是針對數(shù)字類型拆箱函數(shù)，將會比直接操作包裝類型開銷小很多。
連接收集器
想要把Stream的元素拼起來？
//直接連接
String join1 = dishes.stream().map(Dish::getName).collect(Collectors.joining());
//逗號
String join2 = dishes.stream().map(Dish::getName).collect(Collectors.joining(", "));
toList
List<String> names = dishes.stream().map(Dish::getName).collect(toList());
將原來的Stream映射為一個單元素流，然后收集為List。
toSet
Set<Type> types = dishes.stream().map(Dish::getType).collect(Collectors.toSet());
將Type收集為一個set，可以去重復(fù)。
toMap
Map<Type, Dish> byType = dishes.stream().collect(toMap(Dish::getType, d -> d));
有時候可能需要將一個數(shù)組轉(zhuǎn)為map，做緩存，方便多次計算獲取。toMap提供的方法k和v的生成函數(shù)。(注意，上述demo是一個坑，不可以這樣用！??！, 請使用toMap(Function, Function, BinaryOperator))
上面幾個幾乎是最常用的收集器了，也基本夠用了。但作為初學(xué)者來說，理解需要時間。想要真正明白為什么這樣可以做到收集，就必須查看內(nèi)部實現(xiàn)，可以看到，這幾個收集器都是基于java.util.stream.Collectors.CollectorImpl，也就是開頭提到過了Collector的一個實現(xiàn)類。后面自定義收集器會學(xué)習(xí)具體用法。
自定義歸約reducing
前面幾個都是reducing工廠方法定義的歸約過程的特殊情況，其實可以用Collectors.reducing創(chuàng)建收集器。比如，求和
Integer totalCalories = dishes.stream().collect(reducing(0, Dish::getCalories, (i, j) -> i + j)); //使用內(nèi)置函數(shù)代替箭頭函數(shù) Integer totalCalories2 = dishes.stream().collect(reducing(0, Dish::getCalories, Integer::sum));
當然也可以直接使用reduce
Optional<Integer> totalCalories3 = dishes.stream().map(Dish::getCalories).reduce(Integer::sum);
雖然都可以，但考量效率的話，還是要選擇下面這種
int sum = dishes.stream().mapToInt(Dish::getCalories).sum();
根據(jù)情況選擇最佳方案
上面的demo說明，函數(shù)式編程通常提供了多種方法來執(zhí)行同一個操作，使用收集器collect比直接使用stream的api用起來更加復(fù)雜，好處是collect能提供更高水平的抽象和概括，也更容易重用和自定義。
我們的建議是，盡可能為手頭的問題探索不同的解決方案，始終選擇最專業(yè)的一個，無論從可讀性還是性能來看，這一般都是最好的決定。
reducing除了接收一個初始值，還可以把第一項當作初始值
Optional<Dish> mostCalorieDish = dishes.stream()
.collect(reducing((d1, d2) -> d1.getCalories() > d2.getCalories() ? d1 : d2));
reducing
關(guān)于reducing的用法比較復(fù)雜，目標在于把兩個值合并成一個值。
public static <T, U>
Collector<T, ?, U> reducing(U identity,
Function<? super T, ? extends U> mapper,
BinaryOperator<U> op)
首先看到3個泛型，
U是返回值的類型，比如上述demo中計算熱量的，U就是Integer。
關(guān)于T，T是Stream里的元素類型。由Function的函數(shù)可以知道，mapper的作用就是接收一個參數(shù)T，然后返回一個結(jié)果U。對應(yīng)demo中Dish。
?在返回值Collector的泛型列表的中間，這個表示容器類型，一個收集器當然需要一個容器來存放數(shù)據(jù)。這里的？則表示容器類型不確定。事實上，在這里的容器就是U[]。
關(guān)于參數(shù)：
identity是返回值類型的初始值，可以理解為累加器的起點。
mapper則是map的作用，意義在于將Stream流轉(zhuǎn)換成你想要的類型流。
op則是核心函數(shù)，作用是如何處理兩個變量。其中，第一個變量是累積值，可以理解為sum，第二個變量則是下一個要計算的元素。從而實現(xiàn)了累加。
reducing還有一個重載的方法，可以省略第一個參數(shù)，意義在于把Stream里的第一個參數(shù)當做初始值。
public static <T> Collector<T, ?, Optional<T>> reducing(BinaryOperator<T> op)
先看返回值的區(qū)別，T表示輸入值和返回值類型，即輸入值類型和輸出值類型相同。還有不同的就是Optional了。這是因為沒有初始值，而第一個參數(shù)有可能是null，當Stream的元素是null的時候，返回Optional就很意義了。
再看參數(shù)列表，只剩下BinaryOperator。BinaryOperator是一個三元組函數(shù)接口，目標是將兩個同類型參數(shù)做計算后返回同類型的值。可以按照1>2? 1:2來理解，即求兩個數(shù)的最大值。求最大值是比較好理解的一種說法，你可以自定義lambda表達式來選擇返回值。那么，在這里，就是接收兩個Stream的元素類型T，返回T類型的返回值。用sum累加來理解也可以。
上述的demo中發(fā)現(xiàn)reduce和collect的作用幾乎一樣，都是返回一個最終的結(jié)果，比如，我們可以使用reduce實現(xiàn)toList效果：
//手動實現(xiàn)toListCollector --- 濫用reduce， 不可變的規(guī)約---不可以并行
List<Integer> calories = dishes.stream().map(Dish::getCalories)
.reduce(new ArrayList<Integer>(),
(List<Integer> l, Integer e) -> {
l.add(e);
return l;
},
(List<Integer> l1, List<Integer> l2) -> {
l1.addAll(l2);
return l1;
}
);
關(guān)于上述做法解釋一下。
<U> U reduce(U identity,
BiFunction<U, ? super T, U> accumulator,
BinaryOperator<U> combiner);
U是返回值類型，這里就是List
BiFunction<U, ? super T, U> accumulator是是累加器，目標在于累加值和單個元素的計算規(guī)則。這里就是List和元素做運算，最終返回List。即，添加一個元素到list。
BinaryOperator<U> combiner是組合器，目標在于把兩個返回值類型的變量合并成一個。這里就是兩個list合并。
這個解決方案有兩個問題：一個是語義問題，一個是實際問題。語義問題在于，reduce方法旨在把兩個值結(jié)合起來生成一個新值，它是一個不可變歸約。相反，collect方法的設(shè)計就是要改變?nèi)萜?，從而累積要輸出的結(jié)果。這意味著，上面的代碼片段是在濫用reduce方法，因為它在原地改變了作為累加器的List。錯誤的語義來使用reduce方法還會造成一個實際問題：這個歸約不能并行工作，因為由多個線程并發(fā)修改同一個數(shù)據(jù)結(jié)構(gòu)可能會破壞List本身。在這種情況下，如果你想要線程安全，就需要每次分配一個新的List，而對象分配又會影響性能。這就是collect適合表達可變?nèi)萜魃系臍w約的原因，更關(guān)鍵的是它適合并行操作。
總結(jié)：reduce適合不可變?nèi)萜鳉w約，collect適合可變?nèi)萜鳉w約。collect適合并行。
分組
數(shù)據(jù)庫中經(jīng)常遇到分組求和的需求，提供了group by原語。在Java里， 如果按照指令式風(fēng)格(手動寫循環(huán))的方式，將會非常繁瑣，容易出錯。而Java8則提供了函數(shù)式解法。
比如，將dish按照type分組。和前面的toMap類似，但分組的value卻不是一個dish，而是一個List。
Map<Type, List<Dish>> dishesByType = dishes.stream().collect(groupingBy(Dish::getType));
這里
public static <T, K> Collector<T, ?, Map<K, List<T>>> groupingBy(Function<? super T, ? extends K> classifier)
參數(shù)分類器為Function，旨在接收一個參數(shù)，轉(zhuǎn)換為另一個類型。上面的demo就是把stream的元素dish轉(zhuǎn)成類型Type，然后根據(jù)Type將stream分組。其內(nèi)部是通過HashMap來實現(xiàn)分組的。groupingBy(classifier, HashMap::new, downstream);
除了按照stream元素自身的屬性函數(shù)去分組，還可以自定義分組依據(jù)，比如根據(jù)熱量范圍分組。
既然已經(jīng)知道groupingBy的參數(shù)為Function, 并且Function的參數(shù)類型為Dish，那么可以自定義分類器為：
private CaloricLevel getCaloricLevel(Dish d) {
if (d.getCalories() <= 400) {
return CaloricLevel.DIET;
} else if (d.getCalories() <= 700) {
return CaloricLevel.NORMAL;
} else {
return CaloricLevel.FAT;
}
}
再傳入?yún)?shù)即可
Map<CaloricLevel, List<Dish>> dishesByLevel = dishes.stream()
.collect(groupingBy(this::getCaloricLevel));
多級分組
groupingBy還重載了其他幾個方法，比如
public static <T, K, A, D>
Collector<T, ?, Map<K, D>> groupingBy(Function<? super T, ? extends K> classifier,
Collector<? super T, A, D> downstream)
泛型多的恐怖。簡單的認識一下。classifier還是分類器，就是接收stream的元素類型，返回一個你想要分組的依據(jù)，也就是提供分組依據(jù)的基數(shù)的。所以T表示stream當前的元素類型，K表示分組依據(jù)的元素類型。第二個參數(shù)downstream，下游是一個收集器Collector. 這個收集器元素類型是T的子類，容器類型container為A，reduction返回值類型為D。也就是說分組的K通過分類器提供，分組的value則通過第二個參數(shù)的收集器reduce出來。正好，上個demo的源碼為：
public static <T, K> Collector<T, ?, Map<K, List<T>>>
groupingBy(Function<? super T, ? extends K> classifier) {
return groupingBy(classifier, toList());
}
將toList當作reduce收集器，最終收集的結(jié)果是一個List<Dish>, 所以分組結(jié)束的value類型是List<Dish>。那么，可以類推value類型取決于reduce收集器，而reduce收集器則有千千萬。比如，我想對value再次分組，分組也是一種reduce。
//多級分組
Map<Type, Map<CaloricLevel, List<Dish>>> byTypeAndCalory = dishes.stream().collect(
groupingBy(Dish::getType, groupingBy(this::getCaloricLevel)));
byTypeAndCalory.forEach((type, byCalory) -> {
System.out.println("----------------------------------");
System.out.println(type);
byCalory.forEach((level, dishList) -> {
System.out.println("\t" + level);
System.out.println("\t\t" + dishList);
});
});
驗證結(jié)果為：
----------------------------------
FISH
DIET
[Dish(name=prawns, vegetarian=false, calories=300, type=FISH)]
NORMAL
[Dish(name=salmon, vegetarian=false, calories=450, type=FISH)]
----------------------------------
MEAT
FAT
[Dish(name=pork, vegetarian=false, calories=800, type=MEAT)]
DIET
[Dish(name=chicken, vegetarian=false, calories=400, type=MEAT)]
NORMAL
[Dish(name=beef, vegetarian=false, calories=700, type=MEAT)]
----------------------------------
OTHER
DIET
[Dish(name=rice, vegetarian=true, calories=350, type=OTHER), Dish(name=season fruit, vegetarian=true, calories=120, type=OTHER)]
NORMAL
[Dish(name=french fries, vegetarian=true, calories=530, type=OTHER), Dish(name=pizza, vegetarian=true, calories=550, type=OTHER)]
總結(jié)：groupingBy的核心參數(shù)為K生成器，V生成器。V生成器可以是任意類型的收集器Collector。
比如，V生成器可以是計算數(shù)目的, 從而實現(xiàn)了sql語句中的select count(*) from table A group by Type
Map<Type, Long> typesCount = dishes.stream().collect(groupingBy(Dish::getType, counting()));
System.out.println(typesCount);
-----------
{FISH=2, MEAT=3, OTHER=4}
sql查找分組最高分select MAX(id) from table A group by Type
Map<Type, Optional<Dish>> mostCaloricByType = dishes.stream()
.collect(groupingBy(Dish::getType, maxBy(Comparator.comparingInt(Dish::getCalories))));
這里的Optional沒有意義，因為肯定不是null。那么只好取出來了。使用collectingAndThen
Map<Type, Dish> mostCaloricByType = dishes.stream()
.collect(groupingBy(Dish::getType,
collectingAndThen(maxBy(Comparator.comparingInt(Dish::getCalories)), Optional::get)));
到這里似乎結(jié)果出來了，但IDEA不同意，編譯黃色報警，按提示修改后變?yōu)椋?/p>
Map<Type, Dish> mostCaloricByType = dishes.stream()
.collect(toMap(Dish::getType, Function.identity(),
BinaryOperator.maxBy(comparingInt(Dish::getCalories))));
是的，groupingBy就變成toMap了，key還是Type，value還是Dish，但多了一個參數(shù)??！這里回應(yīng)開頭的坑，開頭的toMap演示是為了容易理解，真那么用則會被搞死。我們知道把一個List重組為Map必然會面臨k相同的問題。當K相同時，v是覆蓋還是不管呢？前面的demo的做法是當k存在時，再次插入k則直接拋出異常：
java.lang.IllegalStateException: Duplicate key Dish(name=pork, vegetarian=false, calories=800, type=MEAT) at java.util.stream.Collectors.lambda$throwingMerger$0(Collectors.java:133)
正確的做法是提供處理沖突的函數(shù)，在本demo中，處理沖突的原則就是找出最大的，正好符合我們分組求最大的要求。(真的不想搞Java8函數(shù)式學(xué)習(xí)了，感覺到處都是性能問題的坑)
繼續(xù)數(shù)據(jù)庫sql映射，分組求和select sum(score) from table a group by Type
Map<Type, Integer> totalCaloriesByType = dishes.stream() .collect(groupingBy(Dish::getType, summingInt(Dish::getCalories)));
然而常常和groupingBy聯(lián)合使用的另一個收集器是mapping方法生成的。這個方法接收兩個參數(shù)：一個函數(shù)對流中的元素做變換，另一個則將變換的結(jié)果對象收集起來。其目的是在累加之前對每個輸入元素應(yīng)用一個映射函數(shù)，這樣就可以讓接收特定類型元素的收集器適應(yīng)不同類型的對象。我么來看一個使用這個收集器的實際例子。比如你想得到，對于每種類型的Dish，菜單中都有哪些CaloricLevel。我們可以把groupingBy和mapping收集器結(jié)合起來，如下所示:
Map<Type, Set<CaloricLevel>> caloricLevelsByType = dishes.stream() .collect(groupingBy(Dish::getType, mapping(this::getCaloricLevel, toSet())));
這里的toSet默認采用的HashSet，也可以手動指定具體實現(xiàn)toCollection(HashSet::new)
分區(qū)
分區(qū)是分組的特殊情況：由一個謂詞(返回一個布爾值的函數(shù))作為分類函數(shù)，它稱為分區(qū)函數(shù)。分區(qū)函數(shù)返回一個布爾值，這意味著得到的分組Map的鍵類型是Boolean，于是它最多可以分為兩組：true or false. 例如，如果你是素食者，你可能想要把菜單按照素食和非素食分開：
Map<Boolean, List<Dish>> partitionedMenu = dishes.stream().collect(partitioningBy(Dish::isVegetarian));
當然，使用filter可以達到同樣的效果：
List<Dish> vegetarianDishes = dishes.stream().filter(Dish::isVegetarian).collect(Collectors.toList());
分區(qū)相對來說，優(yōu)勢就是保存了兩個副本，當你想要對一個list分類時挺有用的。同時，和groupingBy一樣，partitioningBy一樣有重載方法，可以指定分組value的類型。
Map<Boolean, Map<Type, List<Dish>>> vegetarianDishesByType = dishes.stream()
.collect(partitioningBy(Dish::isVegetarian, groupingBy(Dish::getType)));
Map<Boolean, Integer> vegetarianDishesTotalCalories = dishes.stream()
.collect(partitioningBy(Dish::isVegetarian, summingInt(Dish::getCalories)));
Map<Boolean, Dish> mostCaloricPartitionedByVegetarian = dishes.stream()
.collect(partitioningBy(Dish::isVegetarian,
collectingAndThen(maxBy(comparingInt(Dish::getCalories)), Optional::get)));
作為使用partitioningBy收集器的最后一個例子，我們把菜單數(shù)據(jù)模型放在一邊，來看一個更加復(fù)雜也更為有趣的例子：將數(shù)組分為質(zhì)數(shù)和非質(zhì)數(shù)。
首先，定義個質(zhì)數(shù)分區(qū)函數(shù)：
private boolean isPrime(int candidate) {
int candidateRoot = (int) Math.sqrt((double) candidate);
return IntStream.rangeClosed(2, candidateRoot).noneMatch(i -> candidate % i == 0);
}
然后找出1到100的質(zhì)數(shù)和非質(zhì)數(shù)
Map<Boolean, List<Integer>> partitionPrimes = IntStream.rangeClosed(2, 100).boxed() .collect(partitioningBy(this::isPrime));
相關(guān)文章
這篇文章主要介紹了在Mac OS上安裝Tomcat服務(wù)器的教程,方便進行工作環(huán)境下的Java web開發(fā),需要的朋友可以參考下2015-11-11
springboot整合websocket實現(xiàn)群聊思路代碼詳解
通過springboot引入websocket，實現(xiàn)群聊，通過在線websocket測試進行展示。本文重點給大家介紹springboot整合websocket實現(xiàn)群聊功能，代碼超級簡單，感興趣的朋友跟隨小編一起學(xué)習(xí)吧2021-05-05
這篇文章主要介紹了Spring MVC處理方法返回值過程解析,文中通過示例代碼介紹的非常詳細，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值,需要的朋友可以參考下2020-02-02
大家好，本篇文章主要講的是java中幾種常見的排序算法總結(jié)，感興趣的同學(xué)趕快來看一看吧，對你有幫助的話記得收藏一下2022-01-01
這篇文章主要介紹了Spring 依賴注入實現(xiàn)示例的相關(guān)資料，幫助大家更好的理解和使用spring框架，感興趣的朋友可以了解下2020-11-11
這篇文章主要介紹了使用Java對Hbase進行操作總結(jié),本文通過實例代碼給大家介紹的非常詳細，對大家的學(xué)習(xí)或工作具有一定的參考借鑒價值，需要的朋友可以參考下2020-07-07
Map用于保存具有映射關(guān)系的數(shù)據(jù)，Map集合里保存著兩組值，一組用于保存Map的key，另一組保存著Map的value，和查字典類似，通過key找到對應(yīng)的value，通過頁數(shù)找到對應(yīng)的信息。用學(xué)生類來說，key相當于學(xué)號，value對應(yīng)name，age，sex等信息。用這種對應(yīng)關(guān)系方便查找2021-10-10
SpringBoot AOP AspectJ切面技術(shù)介紹與實現(xiàn)方式
這篇文章主要介紹了Springboot如何使用Aspectj實現(xiàn)AOP面向切面編程，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2022-10-10
這篇文章主要介紹了Java基于自定義類加載器實現(xiàn)熱部署過程解析,文中通過示例代碼介紹的非常詳細，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值,需要的朋友可以參考下2020-03-03
下面小編就為大家分享一篇JAVA中數(shù)組插入與刪除指定元素的實例代碼，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2018-02-02