Java8 Stream对两个 List 遍历匹配数据的优化处理操作
使用场景，有两个List
第一个集合的值为：
{name=张三丰1,id=1}
{name=张三丰2,id=2}
{name=张三丰3,id=3}
{name=张三丰4,id=4}
{name=张三丰5,id=5}
{name=张三丰6,id=6}
{name=张三丰7,id=7}
{name=张三丰8,id=8}
第二个集合的值为：
{grade=61,id=1}
{grade=62,id=2}
{grade=63,id=3}
{grade=64,id=4}
需要根据两个集合中id值相同，就把第二个集合中的grade值赋给第一个集合，如果不匹配，默认grade值为0
结果是这样：
{grade=61,name=张三丰1,id=1}
{grade=62,name=张三丰2,id=2}
{grade=63,name=张三丰3,id=3}
{grade=64,name=张三丰4,id=4}
{grade=0,name=张三丰5,id=5}
{grade=0,name=张三丰6,id=6}
{grade=0,name=张三丰7,id=7}
{grade=0,name=张三丰8,id=8}
具体实现代码：
@Test
publicvoiddemo01(){
List>list=newArrayList>();
for(inti=1;i<9;i++){
Mapmap=newHashMap<>();
map.put("id",i);
map.put("name","张三丰"+i);
list.add(map);
}
Stream>s1=list.stream();
list.stream().forEach(map->System.out.println(map));
List>list2=newArrayList>();
for(inti=1;i<5;i++){
Mapmap2=newHashMap<>();
map2.put("id",i);
map2.put("grade",i+60);
list2.add(map2);
}
list2.stream().forEach(s->System.out.println(s));
/**
*List>resultList=oneList.stream().map(map->twoList.stream()
*.filter(m->Objects.equals(m.get("id"),map.get("id")))
*.findFirst().map(m->{
*map.putAll(m);
*map.put("grade",90);
*returnmap;
*}).orElse(null))
*.filter(Objects::nonNull).collect(Collectors.toList());
*/
/*List>resultList2=list.stream().map(m->{
m.put("grade",0);
for(inti=0;i>resultList2=list.stream().map(m->{
m.put("grade",0);
list2.stream().filter(m2->Objects.equals(m.get("id"),m2.get("id"))).forEach(s->m.put("grade",s.get("grade")));
returnm;
}).collect(Collectors.toList());
resultList2.stream().forEach(s->System.out.println(s));
}
补充知识：Java-8新特性-通过Stream获取两个List复杂对象的交并差集
思路：首先获取两个list的id，通过id比较获取id的交并差集，再通过一次获取list对象里面的交并差集元素
代码直接可运行，个人觉得java8的stream非常类似ES6的集合运算，filter、foreach、map、reduce基本可以一一对应
代码：
packagecom.stream;
importjava.util.ArrayList;
importjava.util.List;
importjava.util.stream.Collectors;
/**
*
*@ClassName:TwoListCopare
*@Description:两个List<对象>取交集\并集\差集
**/
publicclassTwoListCopare{
publicstaticvoidmain(String[]args){
UserDTOuserOld1=newUserDTO("1","aaa",22);
UserDTOuserOld2=newUserDTO("2","bbb",32);
UserDTOuserOld3=newUserDTO("3","ccc",11);
UserDTOuserOld4=newUserDTO("4","ddd",42);
UserDTOuserOld5=newUserDTO("5","bbb",22);
UserDTOuserOld6=newUserDTO("6","eee",24);
UserDTOuserNew1=newUserDTO("7","dada",22);//新增一个
UserDTOuserNew2=newUserDTO("2","bbb",32);//不变一个
UserDTOuserNew3=newUserDTO("3","kaka",33);//更新一个
UserDTOuserNew4=newUserDTO("8","dbdb",42);//新增一个
UserDTOuserNew5=newUserDTO("5","bbb",100);//更新一个
//当然，少了1,4,6
ListmapAdd=newArrayList<>();
ListoldList=newArrayList<>();
ListnewList=newArrayList<>();
//添加老数据
oldList.add(userOld1);
oldList.add(userOld2);
oldList.add(userOld3);
oldList.add(userOld4);
oldList.add(userOld5);
oldList.add(userOld6);
//添加新数据
newList.add(userNew1);
newList.add(userNew2);
newList.add(userNew3);
newList.add(userNew4);
newList.add(userNew5);
//去交集,既获取id相同的交集，需要更新
//1.先提取出id和结果，用map形式
ListoldIds=newArrayList<>();
ListnewIds=newArrayList<>();
oldList.stream().forEach(it->oldIds.add(it.getId()));
newList.stream().forEach(it->newIds.add(it.getId()));
//oldIds.stream().forEach(System.out::println);
//newIds.stream().forEach(System.out::println);
//取交集id
System.out.println("-----------------交集----------------------");
ListcollectUpdate=newIds.stream().filter(it->oldIds.contains(it)).collect(Collectors.toList());
collectUpdate.stream().forEach(System.out::println);
//取对应交集的对象
System.out.println("------------------交集的对象---------------------");
ListuserUpdate=newList.stream().filter(it->collectUpdate.contains(it.getId())).collect(Collectors.toList());
userUpdate.stream().forEach(System.out::println);
//取old的差集
System.out.println("-----------------old的差集----------------------");
ListcollectDelete=oldIds.stream().filter(it->!newIds.contains(it)).collect(Collectors.toList());
collectDelete.stream().forEach((System.out::println));
//取对应old差集对象
System.out.println("-----------------old差集对象----------------------");
ListuserDelete=oldList.stream().filter(it->collectDelete.contains(it.getId())).collect(Collectors.toList());
userDelete.stream().forEach(System.out::println);
//取new的差集
System.out.println("-----------------new的差集----------------------");
ListcollectAdd=newIds.stream().filter(it->!oldIds.contains(it)).collect(Collectors.toList());
collectAdd.stream().forEach((System.out::println));
//取对应old差集对象
System.out.println("-------------------old差集对象--------------------");
ListuserAdd=newList.stream().filter(it->collectAdd.contains(it.getId())).collect(Collectors.toList());
userAdd.stream().forEach(System.out::println);
//取并集
System.out.println("-------------------并集--------------------");
ListallIds=newArrayList<>();
//获取一个包含了oldIds和newIds的总结合,但是没有去重
allIds.addAll(oldIds);
allIds.addAll(newIds);
//去重，获取并集ids的新集合
ListjoinIds=allIds.stream().distinct().collect(Collectors.toList());
joinIds.stream().forEach(System.out::println);
}
}
结果：
ps：并集对象集合并没有写，因为能够得到判断id自然就能得到了
以上这篇Java8Stream对两个List遍历匹配数据的优化处理操作就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持毛票票。
声明：本文内容来源于网络，版权归原作者所有，内容由互联网用户自发贡献自行上传，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任。如果您发现有涉嫌版权的内容，欢迎发送邮件至：czq8825#qq.com（发邮件时，请将#更换为@）进行举报，并提供相关证据，一经查实，本站将立刻删除涉嫌侵权内容。