程序员经验分享-hwhale

java jdk8 使用stream实现两个list集合合并成一个list集合（对象属性的合并）

2023-11-01

java使用stream实现list中对象属性的合并:
根据两个List中的某个相同字段合并成一条List，包含两个List中的字段

一、前言

为什么要用Lambda表达式和Stream流做集合的处理？ 因为效率高、代码简洁、高端大气上档次！

（1）描述：比如一个List集合中List<对象1>，该对象1包含A、B和C列;另外一个List集合中List<对象2>，该对象2包含A、D列;

（2）问题：需要将两个List合成List<对象3>返回,该对象3包含A、B、C、D列

（3）实现：使用stream实现两个list集合合并成一个list集合

简要说明：filter的使用方式为： filter(item -> item的逻辑判断 ) ，其中filter会保留判断条件为true的记录

二、示例

示例1：java8 合并两个 list＜map＞

java8 合并两个 list＜map＞, 并将userId 相同的所有属性合并到一个map中

list1中对象的属性：userId、userName
list2中对象的属性：userId、gender、age
最总集合中对象的属性：userId、userName、gender、age

import java.util.*;
import java.util.stream.Collectors;

/**
 * @author qzz
 */
public class ListTest {

    public static void main(String[] args) {
        mergeList();
    }
    /**
     * @Description: 合并两个list<map>,并将userId相同的其它属性合并
     * @Title: mergeList
     * @param: @return
     * @return: List<Map<String,Object>>
     * @throws
     */
    public static List<Map<String,Object>> mergeList(){
        //构建List集合1
        List<Map<String,Object>> list1 = new ArrayList<>();
        Map<String,Object> data=new HashMap<>();
        data.put("userId","100001");
        data.put("userName","唐僧");
        list1.add(data);

        data=new HashMap<>();
        data.put("userId","100002");
        data.put("userName","八戒");
        list1.add(data);

        data=new HashMap<>();
        data.put("userId","100003");
        data.put("userName","悟空");
        list1.add(data);

        data=new HashMap<>();
        data.put("userId","100004");
        data.put("userName","沙僧");
        list1.add(data);

 		//构建List集合2
        List<Map<String,Object>> list2 = new ArrayList<>();
        data=new HashMap<>();
        data.put("userId","100001");
        data.put("gender","男");
        data.put("age",20);
        list2.add(data);

        data=new HashMap<>();
        data.put("userId","100002");
        data.put("gender","雄");
        data.put("age",1000);
        list2.add(data);

        data=new HashMap<>();
        data.put("userId","100003");
        data.put("gender","雄");
        data.put("age",600);
        list2.add(data);

        data=new HashMap<>();
        data.put("userId","100004");
        data.put("gender","男");
        data.put("age",800);
        list2.add(data);

		//使用stream流把list1和list2根据属性userId合并一个list集合
        List<Map<String, Object>> list = list1.stream().map(m -> {
            list2.stream().filter(m2-> Objects.equals(m.get("userId"),m2.get("userId"))).forEach(m2-> {
                m.put("gender",m2.get("gender"));
                m.put("age",m2.get("age"));
            });
            return m;
        }).collect(Collectors.toList());

        for(Map<String, Object> map:list){
            System.out.println(map.toString());
        }
        return list;
    }
}

合并运行结果：
在这里插入图片描述

示例2：java8 合并两个 list＜T＞

java8 合并两个 list＜T＞, 并将tickeId相同的所有属性合并到一个T中

list1中对象的属性：ticketId、ticketName
list2中对象的属性：ticketId、saleNum、batchAvailableNum
最总集合中对象的属性：ticketId、ticketName、saleNum、batchAvailableNum

import java.util.*;
import java.util.stream.Collectors;

/**
 * @author qzz
 */
public class ListTest1 {

    public static void main(String[] args) {
        mergeList();
    }
    /**
     * @Description: 合并两个list<Ticket>,并将ticketId相同的其它属性合并
     * @Title: mergeList
     * @param: @return
     * @return: List<Ticket>
     * @throws
     */
    public static List<Ticket> mergeList(){
   		//构建List集合1
        List<Ticket> list1 = new ArrayList<>();
        Ticket data=new Ticket();
        data.setTicketId("100001");
        data.setTicketName("唐僧");
        list1.add(data);

        data=new Ticket();
        data.setTicketId("100002");
        data.setTicketName("八戒");
        list1.add(data);

        data=new Ticket();
        data.setTicketId("100003");
        data.setTicketName("悟空");
        list1.add(data);

        data=new Ticket();
        data.setTicketId("100004");
        data.setTicketName("沙僧");
        list1.add(data);

		//构建List集合2
        List<Ticket> list2 = new ArrayList<>();
        data=new Ticket();
        data.setTicketId("100001");
        data.setSaleNum("20");
        data.setBatchAvailableNum("10");
        list2.add(data);

        data=new Ticket();
        data.setTicketId("100001");
        data.setSaleNum("20");
        data.setBatchAvailableNum("10");
        list2.add(data);

        data=new Ticket();
        data.setTicketId("100002");
        data.setSaleNum("1000");
        data.setBatchAvailableNum("600");
        list2.add(data);

        data=new Ticket();
        data.setTicketId("100003");
        data.setSaleNum("600");
        data.setBatchAvailableNum("100");
        list2.add(data);

        data=new Ticket();
        data.setTicketId("100004");
        data.setSaleNum("800");
        data.setBatchAvailableNum("300");
        list2.add(data);
        
 		//使用stream流把list1和list2根据属性ticketId合并一个list集合
        List<Ticket> list = list1.stream().map(m -> {
            list2.stream().filter(m2-> Objects.equals(m.getTicketId(),m2.getTicketId())).forEach(m2-> {
                m.setSaleNum(m2.getSaleNum());
                m.setBatchAvailableNum(m2.getBatchAvailableNum());
            });
            return m;
        }).collect(Collectors.toList());

        for(Ticket ticket:list){
            System.out.println(ticket.getTicketId()+","+ticket.getTicketName()+","+ticket.getSaleNum()+","+ticket.getBatchAvailableNum());
        }
        return list;
    }
}

合并运行结果：
在这里插入图片描述

示例3：java8 合并两个 list＜T＞，集合个数前者小于后者，要后者

list1中对象的属性：ticketId、ticketName
list2中对象的属性：ticketId、batchId
最总集合中对象的属性：ticketId、ticketName、batchId
list1:
ticketId:10001 , ticketName:唐僧
ticketId:10002 , ticketName:八戒
list2:
ticketId:10001 , batchId:1
ticketId:10001 , batchId:2
ticketId:10002 , batchId:1
ticketId:10002 , batchId:2
ticketId:10003 , batchId:2
想要的结果：list1合并到 list 2
ticketId:10001 , ticketName:唐僧,batchId:1
ticketId:10001 , ticketName:唐僧,batchId:2
ticketId:10002 , ticketName:八戒,batchId:1
ticketId:10002 , ticketName:八戒,batchId:2
ticketId:10003 , ticketName:八戒,batchId:2

代码实现：

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * @author qzz
 */
public class ListTest2 {

    public static void main(String[] args) {
        mergeList();
    }
    /**
     * @Description: 合并两个list<map>,并将userId相同的其它属性合并
     * @Title: mergeList
     * @param: @return
     * @return: List<Map<String,Object>>
     * @throws
     */
    public static List<Ticket> mergeList(){
        List<Ticket> list1 = new ArrayList<>();
        Ticket data=new Ticket();
        data.setTicketId("100001");
        data.setTicketName("唐僧");
        list1.add(data);

        data=new Ticket();
        data.setTicketId("100002");
        data.setTicketName("八戒");
        list1.add(data);

        List<Ticket> list2 = new ArrayList<>();
        data=new Ticket();
        data.setTicketId("100001");
        data.setBatchId("1");
        list2.add(data);

        data=new Ticket();
        data.setTicketId("100001");
        data.setBatchId("2");
        list2.add(data);

        data=new Ticket();
        data.setTicketId("100002");
        data.setBatchId("1");
        list2.add(data);

        data=new Ticket();
        data.setTicketId("100002");
        data.setBatchId("2");
        list2.add(data);

        data=new Ticket();
        data.setTicketId("100002");
        data.setBatchId("3");
        list2.add(data);

        //使用stream流把list1合并到list2集合中，根据ticketId属性
        List<Ticket> list = list2.stream().map(m -> {
            list1.stream().filter(m2-> Objects.equals(m.getTicketId(),m2.getTicketId())).forEach(m2-> {
                m.setTicketId(m2.getTicketId());
                m.setTicketName(m2.getTicketName());
            });
            return m;
        }).collect(Collectors.toList());

        for(Ticket ticket:list){
            System.out.println(ticket.getTicketId()+","+ticket.getTicketName()+","+ticket.getBatchId());
        }
        return list;
    }
}

合并运行结果：
在这里插入图片描述

示例4：java8 合并两个 list＜T＞，集合个数前者大于后者，要后者

list1中对象的属性：ticketId、ticketName
list2中对象的属性：ticketId、batchId
最总集合中对象的属性：ticketId、ticketName、batchId
list1:
ticketId:10001 , ticketName:唐僧
ticketId:10002 , ticketName:八戒
list2:
ticketId:10001 , batchId:1
ticketId:10001 , batchId:2

想要的结果：list1合并到 list 2，过滤掉batch不存在的数据
ticketId:10001 , ticketName:唐僧,batchId:1
ticketId:10001 , ticketName:唐僧,batchId:2

代码实现：

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * @author qzz
 */
public class ListTest3 {

    public static void main(String[] args) {
        mergeList();
    }
    /**
     * @Description: 合并两个list<map>,并将userId相同的其它属性合并
     * @Title: mergeList
     * @param: @return
     * @return: List<Map<String,Object>>
     * @throws
     */
    public static List<Ticket> mergeList(){
        List<Ticket> list1 = new ArrayList<>();
        Ticket data=new Ticket();
        data.setTicketId("100001");
        data.setTicketName("唐僧");
        list1.add(data);

        data=new Ticket();
        data.setTicketId("100002");
        data.setTicketName("八戒");
        list1.add(data);

        List<Ticket> list2 = new ArrayList<>();
        data=new Ticket();
        data.setTicketId("100001");
        data.setBatchId("1");
        list2.add(data);

        data=new Ticket();
        data.setTicketId("100001");
        data.setBatchId("2");
        list2.add(data);

//        data=new Ticket();
//        data.setTicketId("100002");
//        data.setBatchId("1");
//        list2.add(data);
//
//        data=new Ticket();
//        data.setTicketId("100002");
//        data.setBatchId("2");
//        list2.add(data);
//
//        data=new Ticket();
//        data.setTicketId("100002");
//        data.setBatchId("3");
//        list2.add(data);

        //使用stream流把list1合并到list2集合中，根据ticketId属性
        List<Ticket> list = list2.stream().map(m -> {
            list1.stream().filter(m2-> Objects.equals(m.getTicketId(),m2.getTicketId())).forEach(m2-> {
                m.setTicketId(m2.getTicketId());
                m.setTicketName(m2.getTicketName());
            });
            return m;
        }).collect(Collectors.toList());

        for(Ticket ticket:list){
            System.out.println(ticket.getTicketId()+","+ticket.getTicketName()+","+ticket.getBatchId());
        }
        return list;
    }
}

合并运行结果：
在这里插入图片描述

延申：一个list 集合合并去重求和

使用stream实现list中对象属性的合并（去重并求和）

说明：
需要对一个List中的对象进行唯一值属性去重，属性求和，对象假设为Student，有id、nums、sums三个属性，其中id表示唯一值，需要nums与sums进行求和，并最后保持一份。
例如说：(“s1”, 1, 1)，(“s1”,2,3)，(“s2”,3,5)， 求和并去重的话，就是(“s1”, 3, 4)，(“s2”,3,5)

对象属性：

/**
 * @author qzz
 */
public class Student {

    private String id;
    private int nums;
    private int sums;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public int getNums() {
        return nums;
    }

    public void setNums(int nums) {
        this.nums = nums;
    }

    public int getSums() {
        return sums;
    }

    public void setSums(int sums) {
        this.sums = sums;
    }
}

代码实现：

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

/**
 * @author qzz
 */
public class StudentList {

    public static void main(String[] args) {

        List<Student> list = new ArrayList<>();

        Student s1 = new Student();
        s1.setId("s1");
        s1.setNums(1);
        s1.setSums(1);
        list.add(s1);

        s1 = new Student();
        s1.setId("s1");
        s1.setNums(2);
        s1.setSums(3);
        list.add(s1);

        s1 = new Student();
        s1.setId("s2");
        s1.setNums(3);
        s1.setSums(5);
        list.add(s1);

        //合并去重求和
        List<Student> result = merge(list);
        result.stream().forEach(e->{
            System.out.println("id:"+e.getId()+",nums:"+e.getNums()+",sums:"+e.getSums());
        });

    }

    /**
     * 将id进行合并nums, sums 相加道回合并后的集合使用Java8的流进行处理
     * @return
     */
    public static List<Student> merge(List<Student> list){

        List<Student> result = list.stream()
                .collect(Collectors.toMap(Student::getId, a->a,(o1,o2)->{
                    o1.setNums(o1.getNums()+o2.getNums());
                    o1.setSums(o1.getSums()+o2.getSums());
                    return o1;
                })).values().stream().collect(Collectors.toList());
        return result;
    }
}

运行结果：
在这里插入图片描述

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

Java

list

开发语言

java jdk8 使用stream实现两个list集合合并成一个list集合（对象属性的合并） 的相关文章

随机推荐

  • SpringBoot项目后端开发逻辑梳理总结

    SpringBoot项目中包含Mapper层 Dao层 Entity层 model层 DTO层 VO层 Service层和Controller层 本篇以学生信息表增删改查为例 梳理各个层之间的逻辑关系 开发流程和注意事项 目录 一 各层之间

  • Upload-labs文件上传漏洞（MIME限制）——Pass02（详解）

    0 00 题目描述 本题要求对数据包中的MIME进行检查 0 01 MIME介绍 所以首先要搞清楚MIME在数据包的哪里 MIME是个什么 关于MIME 由百度百科可知 MIME Multipurpose Internet Mail Ext

  • 如何提高oracle数据库的性能,想提高Oracle性能，如何优化数据库？

    我们今天主要向大家介绍的是如何优化数据库来大提高Oracle性能 以下我们就介绍几个比较简单的步骤来大幅的提高Oracle性能 沃尔玛你很形象将其比喻成优化数据库的三板斧 数据库优化的讨论可以说是一个永恒的主题 资深的Oracle优化人员通

  • chatgpt赋能python：如何放大Python运行出来的图

    如何放大Python运行出来的图 Python是一种流行的编程语言 广泛应用于数据科学 人工智能 机器学习等领域 在这些领域 数据图表是非常重要的 而将这些图表放大可以帮助我们更好地理解数据 发现规律和趋势 在Python中 matplot

  • vue-json-view 一款用于展示json的vue组件，支持大体积json文件快速解析渲染

    在线示例 开发背景 项目开发过程中遇到展示json的场景 且json文件体积过大 小则几百kb 也尝试了已经开源的部分组件 但由于节点过多 渲染速度过慢 无法使用 已有项目技术选型为vue 无法再使用react相关技术 所以考虑自己开发一款

  • 【数据结构】--栈--括号匹配

    在pop 那个地方卡了好一会 原来是NULL这个情况没有考虑 用栈实现 输入一行符号 以 结束 判断其中的括号是否匹配 括号包括 lt gt 例如 输入 Result as x lt lt gt gt right a b gt The 6

  • Cookie详细分析及JSP Cookie操作

    Http协议中Cookie详细介绍 Cookie简介 网络早期最大的问题之一是如何管理状态 即服务器无法知道两个请求是否来自同一个客户端 用户 当时最简单的方法是在请求时 在页面中插入一些参数 并在下一个请求中传回参数 这需要使用包含参数的

  • 计算机网络题库---选择题刷题训练（100多道精品）

    第一章 概述 1 下列四项内容中 不属于Internet 因特网 基本功能是 D A 电子邮件 B 文件传输 C 远程登录 D 实时监测控制 2 Internet是建立在 C 协议集上的国际互联网络 A IPX B NetBEUI C TC

  • RT-Thread：RW007-通讯速度

    目录 1 测量方法 2 硬件准备 3 软件准备 4 使用env配置工程 5 代码修改 下载测试下行速度 6 代码修改 下载测试上行速度 7 总结 1 测量方法 影响通讯速度原因 1 单片机运行速度 2 单片机和RW007通讯的速度 3 RW

  • 常用矩阵定义概念

    1 托普勒斯矩阵 Toeplitz matrix 一维情况下 行响亮不断的向右一定一格形成的循环矩阵 2 双块循环矩阵 doubly block circulant matrix 这是卷积核展开之后 加速与图像卷积过程 因为是两行两行一起循

  • Python爬虫编程实践--task01

    主要内容 HTTP基础 HTML基础 requests get的使用 API的使用 HTTP HTTP是一个客户端 用户 和服务器端 网站 之间进行请求和应答的标准 通过使用网页浏览器 网络爬虫或者其他工具 客户端可以向服务器上的指定端口

  • jersey实现web service接口+客户端调用

    jersey实现web service接口 客户端调用 jersey百度百科 Jersey是一个RESTFUL请求服务JAVA框架 与常规的JAVA编程使用的struts框架类似 它主要用于处理业务逻辑层 与Struts类似 它同样可以和h

  • 手机app登录显示服务器异常,手机app 连接云服务器异常

    手机app 连接云服务器异常 内容精选 换一换 通过内网连接云手机实例时 需要在租户VPC中创建一台弹性云服务器 作为连接云手机的跳板机器 若创建云手机服务器时未使用自定义网络 还需在云手机租户的VPC和服务器所在VPC之间建立对等连接 如

  • RSA算法的详细设计（C++）及不同优化策略的比较

    本篇文章总结了我对RSA算法的理解和设计 并在后文对优化运行效率的方法做了对比分析 一 RSA算法简介 密码学是研究如何隐密地传递信息的学科 它被认为是数学和计算机科学的分支 和信息论也密切相关 在很久之前的传统密码学中 使用的都是对称加密

  • DXLAM、ubuntu16、tf1.13、anaconda环境配置

    DXSLAM环境的点点滴滴 配置该代码环境有两种方法 方法一 利用docker 方法二 直接配置 配置流程 1 配置ORBSLAM2环境 1 1ORB SLAM2配置 1 2测试单目并处理RGBD的数据集 2 配置tf环境 2 1 配置an

  • Sqoop MySQL 8 迁移Hadoop 3 提示:master:9000/sqoop/base-house already exists

    今天尝试使用Sqoop 将MySQL 8 指定库表数据 迁移至Hadoop 3 提示如下错误 2023 03 01 14 52 20 547 ERROR tool ImportTool Import failed org apache ha

  • 李航-机器学习-感知机（perceptron)-原始形式

    机器学习 感知机 perceptron 感知机模型 感知机模型 感知机学习策略 感知机算法实现 代码实现 运行程序可得 运行程序 感知机模型 感知机是一种线性的 二类分类模型 可以将空间划分为正类和负类 是一种判别模型 输入为具体的实例 输

  • 数字图像处理——实验一 离散傅里叶变换（代码）

    clc clear close all a imread Lena512C bmp f rgb2gray a 原图为三维图像 转为二维图像 figure 1 subplot 2 2 1 imshow f title 原图像 H fft2 f

  • python 绘制箱型图（boxplot）时如何去掉出现的连续散点

    问题如上所示 绘制箱型图时发现在箱型图的上下边界出现许多散点 如何去除呢 只需要在绘制时添加一个命令即可 ax boxplot data h 0 就是这一步就可以去除连续的散点 showmeans True vert True vertic

  • java jdk8 使用stream实现两个list集合合并成一个list集合（对象属性的合并）

    java使用stream实现list中对象属性的合并 根据两个List中的某个相同字段合并成一条List 包含两个List中的字段 目录 一 前言 二 示例 示例1 java8 合并两个 list map 示例2 java8 合并两个 li

热门标签