关于collect.stream().collect()方法的使用

						**

关于collect.stream().collect()方法的使用

最近新入职了一家公司,在一个功能的时候,查看源代码逻辑,发现这个地方有点看不懂(可能是我自己太菜),我把这块代码贴出来,供大家查看.

可以看到我图中画横线的地方,参数已经传递完毕,后面的操作都是对整个list进行操作,用了如下代码
.stream().collect(Collectors.toMap(AccElement::getEle_code, accElement -> accElement, (key1, key2) -> key2));
,因为看不懂,大概在网上搜了一下,了解到一下是stream的一写用法
Stream的用法:
1:简单无存储,属于数据源的一个单向视图.
2.对于stream的任何修改,都不会修改到原来的list,这就是我上面所说的单向.比如你对strram进行排序或者删除操作,原来的list不会作任何改变,会产生一个新的你操作之后的stream视图.
3.惰式执行 对 stream的操作并不回立即执行,如果用户真正需要的时候才会执行(有点像system.gc()方法哈)
4.消费即消失 生成的stream视图一旦遍历就会消失,如果需要则要重新生成
我自己写了一个测试类,检测测试结果.
实体类代码
public class Student {
private String name;
private String sex;
private String age;
private String height;
private String weight;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
public String getHeight() {
return height;
}
public void setHeight(String height) {
this.height = height;
}
public String getWeight() {
return weight;
}
public void setWeight(String weight) {
this.weight = weight;
}

}
测试类代码:

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class StreamTest {
public static void main(String[] args) {
Map<String,Student> stuMap=new HashMap<String, Student>();
List stuList=new ArrayList();
Student stu1=new Student();
stu1.setName(“张三”);
stu1.setSex(“男”);
stu1.setAge(“18”);
stu1.setHeight(“178”);
stu1.setHeight(“75”);
Student stu2=new Student();
stu2.setName(“王静”);
stu2.setSex(“女”);
stu2.setAge(“14”);
stu2.setHeight(“165”);
stu2.setHeight(“48”);
Student stu3=new Student();
stu3.setName(“李四”);
stu3.setSex(“男”);
stu3.setAge(“24”);
stu3.setHeight(“180”);
stu3.setHeight(“75”);
stuList.add(stu1);
stuList.add(stu2);
stuList.add(stu3);
stuMap=stuList.stream().collect(Collectors.toMap(Student::getSex,student->student, (key1, key2) -> key2));
stuMap.get(“男”);//主要是为了调试stuMap
System.out.println(stuMap);
}

}

可以看到stuMap只有两条数据,因为在上述代码加粗部分使用getSex作为key的 ,我插入了三条数据 ,但是set只有男和女两种,为了验证我的猜想,我把最后一个人性别设置为不明,看看几条数据

果然不出所料,出现三条数据.
我又查看了Collectors.toMap的使用方法.已经有博主写的很详细了,
原文地址:https://zhangzw.com/posts/20191205.html

引用开始:

在实际项目中我们经常会用到 List 转 Map 操作，在过去我们可能使用的是 for 循环遍历的方式。举个例子：

先定义类：

// 简单对象
@Accessors(chain = true) // 链式方法
@lombok.Data
class User {
private String id;
private String name;
}
然后有这样一个 List：

List userList = Lists.newArrayList(
new User().setId(“A”).setName(“张三”),
new User().setId(“B”).setName(“李四”),
new User().setId(“C”).setName(“王五”)
);
我们希望转成 Map 的格式为：

A-> 张三
B-> 李四
C-> 王五
过去的做法（循环）：

Map<String, String> map = new HashMap<>();
for (User user : userList) {
map.put(user.getId(), user.getName());
}
使用 Java8 特性
Java8 中新增了 Stream 特性，使得我们在处理集合操作时更方便了。

以上述例子为例，我们可以一句话搞定：

userList.stream().collect(Collectors.toMap(User::getId, User::getName));
当然，如果希望得到 Map 的 value 为对象本身时，可以这样写：

userList.stream().collect(Collectors.toMap(User::getId, t -> t));
或：
userList.stream().collect(Collectors.toMap(User::getId, Function.identity()));
关于 Collectors.toMap 方法
Collectors.toMap 有三个重载方法：

toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper);
toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper,
BinaryOperator mergeFunction);
toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper,
BinaryOperator mergeFunction, Supplier mapSupplier);
参数含义分别是：

keyMapper：Key 的映射函数

valueMapper：Value 的映射函数

mergeFunction：当 Key 冲突时，调用的合并方法

mapSupplier：Map 构造器，在需要返回特定的 Map 时使用

还是用上面的例子，如果 List 中 userId 有相同的，使用上面的写法会抛异常：

List userList = Lists.newArrayList(
new User().setId(“A”).setName(“张三”),
new User().setId(“A”).setName(“李四”), // Key 相同
new User().setId(“C”).setName(“王五”)
);
userList.stream().collect(Collectors.toMap(User::getId, User::getName));

// 异常：
java.lang.IllegalStateException: Duplicate key 张三
at java.util.stream.Collectors.lambda$throwingMerger$114(Collectors.java:133)atjava.util.HashMap.merge(HashMap.java:1245)atjava.util.stream.Collectors.lambda$toMap$172(Collectors.java:1320)
at java.util.stream.ReduceOps$3ReducingSink.accept(ReduceOps.java:169)atjava.util.ArrayList$ArrayListSpliterator.forEachRemaining(ArrayList.java:1374)
at java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:481)
at java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:471)
at java.util.stream.ReduceOps$ReduceOp.evaluateSequential(ReduceOps.java:708)
at java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:234)
at java.util.stream.ReferencePipeline.collect(ReferencePipeline.java:499)
at Test.toMap(Test.java:17)
…
这时就需要调用第二个重载方法，传入合并函数，如：

userList.stream().collect(Collectors.toMap(User::getId, User::getName, (n1, n2) -> n1 + n2));

// 输出结果：
A-> 张三李四
C-> 王五
第四个参数（mapSupplier）用于自定义返回 Map 类型，比如我们希望返回的 Map 是根据 Key 排序的，可以使用如下写法：

List userList = Lists.newArrayList(
new User().setId(“B”).setName(“张三”),
new User().setId(“A”).setName(“李四”),
new User().setId(“C”).setName(“王五”)
);
userList.stream().collect(
Collectors.toMap(User::getId, User::getName, (n1, n2) -> n1, TreeMap::new)
);

// 输出结果：
A-> 李四
B-> 张三
C-> 王五

引用结束

最后再着重讲一下这一行代码
stuMap=stuList.stream().collect(Collectors.toMap(Student::getSex,student->student, (key1, key2) -> key2));

这行代码Student::getSex,student->student代表利用student.getSex作为key,student作为value,同理如果想用student.name作为value可以这样写
stuMap=stuList.stream().collect(Collectors.toMap(Student::getSex,Student::getName, (key1, key2) -> key2));
但是需要修改stuMap为Map<String,String>数据类型
(key1, key2) -> key2)这一行代码指的是合并冲突的解决办法,比如最开始两男一女时,
第一个男被合并到第二个男上面,同理如果想以key的第一个值为准,可以写成(key1, key2) -> key1
到这里原来项目中的这行代码就很清楚了,这里就不做解释了,毕竟你们看我的demo就能明白.