Java Stream map, Collectors(toMap, toList, toSet, groupingBy, collectingAndThen)使用案例
.map 以及 toList 方法聯(lián)合使用案例
/**
* .map .collect(Collectors.toList)
*/
private static void method2(){
List<MyPerson> collect = Stream.of("1:name1", "2:name2").map(new Function<String, MyPerson>() {
@Override
public MyPerson apply(String s) {
String[] split = s.split(":");
MyPerson myPerson = new MyPerson(Integer.valueOf(split[0]), split[1]);
return myPerson;
}
}).collect(Collectors.toList());
System.out.println(collect.toString());
}實際輸出
這里我重寫了MyPerson 類的toString 等方法
[MyPerson{id=1, name='name1'}, MyPerson{id=2, name='name2'}]Stream.of(“1:name1”, “2:name2”) 譯為將多個of 中的元素轉(zhuǎn)為Stream 中的集合元素
.map 這里作用為將 Function中的第一個泛型元素也就是Stream 中的元素泛型，轉(zhuǎn)為 MyPerson 對象，這里 MyPerson 為我自己定義的對象，只有id 和 name 兩個屬性。 重寫的方法 apply 為對每個Stream 中的String 元素的操作，并且通過這個方法將返回預(yù)期的 MyPerson 對象，即 .map 作用為將Stream 中的每一個元素轉(zhuǎn)為另一種元素的映射操作，實際就是一個轉(zhuǎn)換的中間方法。
.collect 說明接下來要使用集合類操作 即使用了 Collectors.toList() 方法，該方法最終會將Stream 中的元素輸出為 List 類型的對象
上一案例 Collectors toMap使用
/**
* .map .collect(Collectors.toMap())
*/
private static void method3(){
Map<Integer, MyPerson> collect = Stream.of("1:name1", "2:name2").map(new Function<String, MyPerson>() {
@Override
public MyPerson apply(String s) {
String[] split = s.split(":");
MyPerson myPerson = new MyPerson(Integer.valueOf(split[0]), split[1]);
return myPerson;
}
}).collect(Collectors.toMap(MyPerson::getId, Function.identity()));
System.out.println(collect.toString());
MyPerson myPerson = collect.get(1);
System.out.println(myPerson);
MyPerson myPerson1 = collect.get(2);
System.out.println(myPerson1.toString());
}實際輸出
{1=MyPerson{id=1, name='name1'}, 2=MyPerson{id=2, name='name2'}}
MyPerson{id=1, name='name1'}
MyPerson{id=2, name='name2'}
即 .collect(Collectors.toMap(MyPerson::getId, Function.identity()));
意義為使用集合方法中的toMap() 方法，toMap中，第一個參數(shù)為作為Map 的key, Function.identity() 對應(yīng)key 的值為 當(dāng)前元素自己，結(jié)果如上展示
上述案例也可以寫為：map 中 可以直接使用lambda 表達式給出返回結(jié)果 s 即Stream 中的每個元素
/**
* .map .collect(Collectors.toMap()) lambda
*/
private static void method4(){
Map<Integer, MyPerson> collect = Stream.of("1:name1", "2:name2").map(s -> {
String[] split = s.split(":");
MyPerson myPerson = new MyPerson(Integer.valueOf(split[0]), split[1]);
return myPerson;
}).collect(Collectors.toMap(MyPerson::getId, Function.identity()));
System.out.println(collect.toString());
MyPerson myPerson = collect.get(1);
System.out.println(myPerson);
MyPerson myPerson1 = collect.get(2);
System.out.println(myPerson1.toString());
}上述案例
可以進一步簡寫為：即 .map 中可以直接使用引用某一已經(jīng)存在的方法來獲取結(jié)果 MyPerson::transEntity 見末尾MyPerson 中定義的方法
/**
* .map .collect(Collectors.toMap()) lambda level up MapTrans
*/
private static void method5(){
Map<Integer, MyPerson> collect = Stream.of("1:name1", "2:name2").map(MyPerson::transEntity)
.collect(Collectors.toMap(MyPerson::getId, Function.identity()));
System.out.println(collect.toString());
MyPerson myPerson = collect.get(1);
System.out.println(myPerson);
MyPerson myPerson1 = collect.get(2);
System.out.println(myPerson1.toString());
}其中 Function.identity() 也可以如下寫法 s -> s 也表示直接獲取當(dāng)前對象作為 Map的值
/**
* .map .collect(Collectors.toMap()) lambda level up MapTrans
*/
private static void method6(){
Map<Integer, MyPerson> collect = Stream.of("1:name1", "2:name2").map(MyPerson::transEntity)
.collect(Collectors.toMap(MyPerson::getId, s -> s));
System.out.println(collect.toString());
MyPerson myPerson = collect.get(1);
System.out.println(myPerson);
MyPerson myPerson1 = collect.get(2);
System.out.println(myPerson1.toString());
}toList 使用案例
private static void lambdaTestToList(){
String m = "a,b,c,d,d,d,d,d";
Stream.of("a", "aa", "aaa", "b", "bb", "bbb").collect(Collectors.toList()).forEach((item) -> {
System.out.println(item);
});
System.out.println("*******************");
Stream.of(m.split(",")).collect(Collectors.toList()).forEach((item) -> {
System.out.println(item);
});
System.out.println("*******************");
MyPerson myPerson = new MyPerson(1, "545");
MyPerson myPerson1 = new MyPerson(2, "333");
MyPerson myPerson2 = new MyPerson(3, "445");
List<MyPerson> list = new ArrayList<>();
list.add(myPerson);
list.add(myPerson2);
list.add(myPerson1);
List<List<MyPerson>> collect = Stream.of(list).collect(Collectors.toList());
List<Object> collect1 = Stream.of(list.toArray()).collect(Collectors.toList());
System.out.println("*******************");
collect.stream().forEach(item -> {
System.out.println(item.toString());
});
System.out.println("*******************");
collect1.stream().forEach(item -> {
System.out.println(item);
});
}輸出結(jié)果：
a
aa
aaa
b
bb
bbb
*******************
a
b
c
d
d
d
d
d
*******************
*******************
[MyPerson{id=1, name='545'}, MyPerson{id=3, name='445'}, MyPerson{id=2, name='333'}]
*******************
MyPerson{id=1, name='545'}
MyPerson{id=3, name='445'}
MyPerson{id=2, name='333'}Process finished with exit code 0
可以看的出常見的 逗號拼接方式的字符串也可以通過 toList 快速轉(zhuǎn)為我們常用的 list 形式并做一定的操作
toSet
上述案例中直接list 轉(zhuǎn) set 做去重和類型轉(zhuǎn)換十分快捷
// 定義
private static String arrayStr = "1,2,3,4, 5,6,7";
private static String arrayStrEN = "a,b,c,d,d,d,f";
private static List<MyPerson> listObject = new ArrayList<>();
private static List<JSONObject> listJsonObject = new ArrayList<>();
static {
MyPerson myPerson = new MyPerson(1, "545");
MyPerson myPerson1 = new MyPerson(2, "333");
MyPerson myPerson2 = new MyPerson(3, "445");
MyPerson myPerson3 = new MyPerson(2, "333");
listObject.add(myPerson);
listObject.add(myPerson1);
listObject.add(myPerson2);
listObject.add(myPerson3);
JSONObject object = new JSONObject();
object.put("dep", 124);
object.put("userId", "14");
object.put("names", "aka");
JSONObject object1 = new JSONObject();
object1.put("dep", 124);
object1.put("userId", "14");
object1.put("names", "aka1");
JSONObject object2 = new JSONObject();
object2.put("dep", 125);
object2.put("userId", "15");
object2.put("names", "aka2");
JSONObject object3 = new JSONObject();
object3.put("dep", 125);
object3.put("userId", "15");
object3.put("names", "aka3");
JSONObject object4 = new JSONObject();
object4.put("dep", 136);
object4.put("userId", "14");
object4.put("names", "aka4");
listJsonObject.add(object);
listJsonObject.add(object1);
listJsonObject.add(object2);
listJsonObject.add(object3);
listJsonObject.add(object4);
}
public static void lambdaToSet(){
Stream.of(arrayStr.split(",")).collect(Collectors.toSet()).forEach(item -> {
System.out.println(item.trim());
});
System.out.println("---------------");
Stream.of(arrayStrEN.split(",")).collect(Collectors.toSet()).forEach(item -> {
System.out.println(item.trim());
});
System.out.println("-----------");
Stream.of(listObject.toArray()).collect(Collectors.toSet()).forEach(item -> {
System.out.println(item);
});
}輸出結(jié)果：
1
2
3
4
5
6
7
---------------
a
b
c
d
f
-----------
MyPerson{id=2, name='333'}
MyPerson{id=3, name='445'}
MyPerson{id=1, name='545'}
groupingBy collectingAndThen 使用
// 定義
private static List<MyPerson> listObject = new ArrayList<>();
private static List<JSONObject> listJsonObject = new ArrayList<>();
static {
MyPerson myPerson = new MyPerson(1, "545");
MyPerson myPerson1 = new MyPerson(2, "333");
MyPerson myPerson2 = new MyPerson(3, "445");
MyPerson myPerson3 = new MyPerson(2, "333");
listObject.add(myPerson);
listObject.add(myPerson1);
listObject.add(myPerson2);
listObject.add(myPerson3);
JSONObject object = new JSONObject();
object.put("dep", 124);
object.put("userId", "14");
object.put("names", "aka");
JSONObject object1 = new JSONObject();
object1.put("dep", 124);
object1.put("userId", "14");
object1.put("names", "aka1");
JSONObject object2 = new JSONObject();
object2.put("dep", 125);
object2.put("userId", "15");
object2.put("names", "aka2");
JSONObject object3 = new JSONObject();
object3.put("dep", 125);
object3.put("userId", "15");
object3.put("names", "aka3");
JSONObject object4 = new JSONObject();
object4.put("dep", 136);
object4.put("userId", "14");
object4.put("names", "aka4");
listJsonObject.add(object);
listJsonObject.add(object1);
listJsonObject.add(object2);
listJsonObject.add(object3);
listJsonObject.add(object4);
}
public static void lambdaGroupBy(){
System.out.println("--------------按某一屬性分組 返回key Object 的Map");
Map<Integer, List<MyPerson>> collect = listObject.stream().collect(Collectors.groupingBy(MyPerson::getId));
System.out.println(collect.toString());
System.out.println("--------------按某些屬性的組合作為鍵 返回key Object的Map");
Map<String, List<MyPerson>> collect1 = listObject.stream().collect(Collectors.groupingBy(myPerson -> myPerson.getId() + myPerson.getName() + ""));
System.out.println(collect1.toString());
System.out.println("--------------按JSON 的某些屬性組合作為鍵 返回key Object的Map");
Map<String, List<JSONObject>> collect2 = listJsonObject.stream().collect(Collectors.groupingBy(item -> item.get("dep") + item.getString("userId")));
System.out.println(collect2);
System.out.println("--------------按某一屬性分組后, 獲取當(dāng)前分組后Map的size 可用于統(tǒng)計");
Integer collect3 = listObject.stream().collect(Collectors.collectingAndThen(Collectors.groupingBy(MyPerson::getId), Map::size));
System.out.println(collect3);
}main 中運行 lambdaGroupBy
輸出結(jié)果如下：
--------------按某一屬性分組 返回key Object 的Map
{1=[MyPerson{id=1, name='545'}], 2=[MyPerson{id=2, name='333'}, MyPerson{id=2, name='333'}], 3=[MyPerson{id=3, name='445'}]}
--------------按某些屬性的組合作為鍵 返回key Object的Map
{1545=[MyPerson{id=1, name='545'}], 3445=[MyPerson{id=3, name='445'}], 2333=[MyPerson{id=2, name='333'}, MyPerson{id=2, name='333'}]}
--------------按JSON 的某些屬性組合作為鍵 返回key Object的Map
{12515=[{"names":"aka2","userId":"15","dep":125}, {"names":"aka3","userId":"15","dep":125}], 12414=[{"names":"aka","userId":"14","dep":124}, {"names":"aka1","userId":"14","dep":124}], 13614=[{"names":"aka4","userId":"14","dep":136}]}
--------------按某一屬性分組后, 獲取當(dāng)前分組后Map的size 可用于統(tǒng)計
3
groupingBy 用意為將每一個元素按照某一種屬性或多種屬性執(zhí)行分組操作，返回為map key 為分組的屬性條件，值為當(dāng)前元素
collectingAndThen 即執(zhí)行集合操作后再執(zhí)行某一方法
總結(jié)
通過 stream 使一般的集合對象成為可以執(zhí)行Stream 操作的對象map 將每一個元素通過某些操作轉(zhuǎn)化為另一種元素
Collectors 中
toMap 將每一種元素轉(zhuǎn)為Map類型的結(jié)構(gòu)，可以通過鍵拿到對應(yīng)的元素，這里相當(dāng)于是 數(shù)據(jù)庫中通過id 獲取某一條記錄的數(shù)據(jù)一樣，相當(dāng)于自己建立了一個數(shù)據(jù)索引，對于數(shù)據(jù)暫存和優(yōu)化以及操作十分方便，而且可以省去繁瑣的簡單操作將數(shù)據(jù)轉(zhuǎn)為這一數(shù)據(jù)結(jié)構(gòu)的過程，而且符合獲取數(shù)據(jù)時的習(xí)慣。
toList 快速將多個元素轉(zhuǎn)為List 而不用自己執(zhí)行遍歷操作
toSet 快速將多個元素轉(zhuǎn)為set集合 可以用于去重操作
groupingBy 通過該方法可以快速對數(shù)據(jù)分組，同樣省去了自己封裝簡單代碼的過程
collectingAndThen 集合類操作和其他結(jié)果的聚合操作，同時是為了提升效率
雖然一般情況下不需要考慮代碼的速度問題，但這里還是說一下Stream 的使用場景經(jīng)過對比，其實最簡單的循環(huán)迭代方式對于較少和較簡單的數(shù)據(jù)來說 for 等基本操作反而花費的時間是要比 Stream 快的。
這里我理解 Stream 是使用時間換來了代碼的優(yōu)化和簡潔，但是對于不常使用Stream的人來說易讀性并不太友好。
Stream 使用場景如下：
- 在循環(huán)迭代次數(shù)較少的情況下，常規(guī)的迭代方式性能反而更好
- 在單核CPU服務(wù)器配置環(huán)境中，常規(guī)迭代方式更有優(yōu)勢
- 在大數(shù)據(jù)循環(huán)迭代中，如果服務(wù)器是多核CPU的情況，采用Stream的并行迭代優(yōu)勢明顯
MyPerson對象定義
equals hashCode 為了對象比較一定需要重寫 直接使用代碼生成的即可
import java.util.Objects;
public class MyPerson {
private int id;
private String name;
public MyPerson() {
}
public MyPerson(int id, String name) {
this.id = id;
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "MyPerson{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
MyPerson myPerson = (MyPerson) o;
return id == myPerson.id &&
Objects.equals(name, myPerson.name);
}
@Override
public int hashCode() {
return Objects.hash(id, name);
}
public static MyPerson transEntity(String s){
String[] split = s.split(":");
MyPerson myPerson = new MyPerson(Integer.valueOf(split[0]), split[1]);
return myPerson;
}
}到此這篇關(guān)于Java Stream map, Collectors(toMap, toList, toSet, groupingBy, collectingAndThen)使用案例的文章就介紹到這了,更多相關(guān)Java Stream map, Collectors內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！
相關(guān)文章
這篇文章主要介紹了JAVA多線程編程,結(jié)合實例形式總結(jié)分析了多線程、鎖、線程池等相關(guān)原理及使用技巧,需要的朋友可以參考下2019-09-09
FilenameUtils.getName?函數(shù)源碼分析
這篇文章主要為大家介紹了FilenameUtils.getName?函數(shù)源碼分析，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2022-09-09
java網(wǎng)絡(luò)編程基礎(chǔ)知識介紹
這篇文章主要介紹了java網(wǎng)絡(luò)編程基礎(chǔ)知識介紹，涉及OSI分層模型和TCP/IP分層模型的對應(yīng)關(guān)系、IP地址、端口號、tcp、udp等相關(guān)內(nèi)容，還是比較不錯的，這里分享給大家，供需要的朋友參考。2017-11-11
下面小編就為大家?guī)硪黄狫ava線程代碼的實現(xiàn)方法。小編覺得挺不錯的，現(xiàn)在就分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2017-08-08
在Java中可以使用不同的實現(xiàn)類來創(chuàng)建和初始化Set集合,下面這篇文章主要給大家介紹了關(guān)于Java中Set集合的基本使用方法,文中通過代碼介紹的非常詳細(xì),需要的朋友可以參考下2024-07-07
springboot中@PostConstruct注解使用小結(jié)
本文主要介紹了springboot中@PostConstruct注解使用小結(jié),文中通過示例代碼介紹的非常詳細(xì),對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值,需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2025-01-01
本文主要介紹了jdk線程池的實現(xiàn)，文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2023-04-04
使用FormData上傳二進制文件、對象、對象數(shù)組方式
這篇文章主要介紹了使用FormData上傳二進制文件、對象、對象數(shù)組方式,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教2024-01-01
HTTP 415錯誤-Unsupported media type詳解
這篇文章主要介紹了HTTP 415錯誤-Unsupported media type詳解,本篇文章通過簡要的案例,講解了該項技術(shù)的了解與使用,以下就是詳細(xì)內(nèi)容,需要的朋友可以參考下2021-08-08
今天帶大家學(xué)習(xí)Spring的相關(guān)知識,文章圍繞著Spring事務(wù)失效的原因等相關(guān)知識展開,文中有非常詳細(xì)的介紹及圖文示例,需要的朋友可以參考下2021-06-06