Java使用Stream流的Lambda语法进行List转Map的操作方式

2025-05-07 15:50
文章标签 java 进行 使用 操作 语法 方式 list map stream lambda

本文主要是介绍Java使用Stream流的Lambda语法进行List转Map的操作方式，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

《Java使用Stream流的Lambda语法进行List转Map的操作方式》：本文主要介绍Java使用Stream流的Lambda语法进行List转Map的操作方式,具有很好的参考价值,希望对大...

注：标题的<>被替换成了《》，标题带有<>会因为Bug被吞。

背景

在平时开发过程中难免会碰到有些时候需要将一个List转成Map又或者是将Map转成List，我们可以采用粗暴的方式来进行转换，但这样一是不够优雅，二是数据过多的时候性能不是很高。

Lambda如果平时经常使用就可以知道这种语法糖有多方便使用，可以让代码变得十分简洁，而本篇便是用来说明使用Stream流的Lambda语法来优雅的进行List和Map的互转操作，并分析其性能差异。

一些简单的便不做分析了，比如map()、peek()、filter()等方法，主要着重分析collect()的toMap()方法。

Stream流的Lambda语法应用实例

1、定义要操作的UserDto

先定义一个UserDto以便直接后续使用，其代码如下：

public class UserDto {
    private String name;
    private String sex;
    private String job;
    @Override
    public String toString() {
        return "{\"name\":\"" + name +
                "\",\"sex\":\"" + sex +
                "\",\"job\":\"" + job + "\"}";
    
    }
    // 后面其它的属性和getter、setter方法都忽略
}

2、List转成Map

List转成Map有很多方式，使用foreach的方式什么转换都可以完成，但在本篇将会分享几个遍历的操作。

List《UserDto》转成Map《String, UserDto》

首先分享一下最简单的转换：

由List<UserDto>转成以UserDto的name当成Key，而UserDto当成Value的Map操作，即Map<String, UserDto>形式。

代码如下：

public class MainTest {
    public static void main(String[] args) {
        UserDto userDto1 = new UserDto("test1", "man", "worker1");
        UserDto userDto2 = new UserDto("test2", "woman", "worker2");
        UserDto userDto3 = new UserDto("test3", "woman", "worker2");
        UserDto userDto4 = new UserDto("test4", "man", "worker3");
        List<UserDto> userList = Arrays
            .asList(userDto1, userDto2, userDto3, userDto4);
        System.out.println(userList);
        // 使用stream流将List转成Map
        Map<String, UserDto> userMap = userList.stream()
            .collect(Collectors.toMap(UserDto::getName, dto2 -> dto2));
        System.out.println(userMap);
    }
}
-------------打印结果-------------
[{"name":"test1","sex":"man","job":"worker1"}, {"namhttp://www.chinasem.cne":"test2","sex":"woman","job":"worker2"}, 
{"name":"test3","sex":"woman","job":"worker2"}, {"name":"test4","sex":"man","job":"worker3"}]


{test4={"name":"test4","sex":"man","job":"worker3"},test2={"name":"test2","sex":"woman","job":"worker2"}, 
test3={"name":"test3","sex":"woman","job":"worker2"},test1={"name":"test1http://www.chinasem.cn","sex":"man","job":"worker1"}}

List《UserDto》转成Map《String, Map《String, Object》》

接下来分享下将List<UserDto>转成Map<String, Map<String, Object>>形式的Lambda操作：

public class MainTest {
    public static void main(String[] args) {
        UserDto userDto1 = new UserDto("test1", "man", "worker1");
        UserDto userDto2 = new UserDto("test2", "woman", "worker2");
        UserDto userDto3 = new UserDto("test3", "woman", "worker2");
        UserDto userDto4 = new UserDto("test4", "man", "worker3");
        List<UserDto> userList = Arrays
            .asList(userDto1, userDto2, userDto3, userDto4);
        System.out.println(userList);
        // 使用stream流将List转成Map
        Map<String, Map<String, Object>> userMap = userList.stream()
        .collect(Collectors.toMap(UserDto::getName, dto2 ->
                new HashMap<String, Object>(){{
                    put("name", dto2.getName());
                    put("sex", dto2.getSex());
                    put("job", dto2.getJob());}}));
        System.out.println(userMap);
    }
}
-------------打印结果-------------
[{"name":"test1","sex":"man","job":"worker1"}, {"name":"test2","sex":"woman","job":"worker2"}, 
{"name":"test3","sex":"woman","job":"worker2"}, {"name":"test4","sex":"man","job":"worker3"}]


{test4={sex=man, name=test4, job=worker3}, test2={sex=woman, name=test2, job=worker2},
test3={sex=woman, name=test3, job=worker2}, test1={sex=man, name=test1, job=worker1}}

List《UserDto》转Map《String, String》

接下来分享下将List<UserDto>转成Map<String, String>形式的Lambda操作，当然Map中String泛型也可以是Integer、Long甚至其它的类型，按照下面的方式进行相应的替换就行了：

public class MainTest {
    public static void main(String[] args) {
        UserDto userDto1 = new UserDto("test1", "man", "worker1");
        UserDto userDto2 = new UserDto("test2", "woman", "worker2");
        UserDto userDto3 = new UserDto("test3", "woman", "worker2");
        UserDto userDto4 = new UserDto("test4", "man", "worker3");
        List<UserDto> userList = Arrays
            .asList(userDto1, userDto2, userDto3, userDto4);
        System.out.println(userList);
        // 使用stream流将List转成Map
        Map<String, String> userMap = userList.stream()
        .collect(Collectors.toMap(UserDto::getName, UserDto::getSex));
        System.out.println(userMap);
    }
}
-------------打印结果-------------
[{"name":"test1","sex":"man","job":"worker1"}, {"name":"test2","sex":"woman","job":"worker2"}, 
{"name":"test3","sex":"woman","job":"worker2"}, {"name":"test4","sex":"man","job":"worker3"}]


{test4=man, test2=woman, test3=woman, test1=man}

List《Map《String, Object》》转Map《String, UserDto》

由List<Map<String, Object>>转Map<String, UserDto>操作中，Map中的String也可以是Long、Integer或者其它的类型：

public class MainTest {
    public static void main(String[] args) {
        Map<String, Object> userMap1 = new HashMap<String, Object>(8) {{
            put("name", "test1");put("sex", "man");put("job", "worker1");
        }};
        Map<String, Object> userMap2 = new HashMap<String, Object>(8) {{
            put("name", "test2");put("sex", "woman");put("job", "worker2");
        }};
        Map<String, Object> userMap3 = new HashMap<String, Object>(8) {{
            put("name", "test3");put("sex", "woman");put("job", "worker2");
        }};
        Map<String, Object> userMap4 = new HashMap<String, Object>(8) {{
            put("name", "test4");put("sex", "man");put("job", "worker3");
        }};
        List<Map<String, Object>> userList = Arrays.asList(userMap1, userMap2, userMap3, userMap4);
        System.out.println(userList);
        // 使用stream流将List转成Map
        Map<String, UserDto> userMap = userList.stream()
                .collect(Collectors.toMap(map1 -> (String) map1.get("name"), map2 ->
                        new UserDto((String) map2.get("name"), (String) map2.get("sex"), (String) map2.get("job"))));
        System.out.println(userMap);
    }
}
-------------打印结果-------------
[{name=test1, job=worker1, sex=man}, {name=test2, job=worker2, sex=woman}, 
{name=test3, job=worker2, sex=woman}, {name=test4, job=worker3, sex=man}]


{test4={"name":"test4","sex":"man","job":"worker3"}, test2={"name":"test2","sex":"woman","job":"worker2"}, 
test3={"name":"test3","sex":"woman","job":"worker2"}, test1={"name":"test1","sex":"man","job":"worker1"}}

List《Map《String, Object》》转Map《String, String》

由List<Map<String, Object>>转Map<String, String>操作中，Map中的String也可以是Long、Integer或者其它的类型：

public class MainTest {
    public static void main(String[] args) {
        Map<String, Object> userMap1 = new HashMap<String, Object>(8) {{
            put("name", "test1");put("sex", "man");put("job", "worker1");
        }};
        Map<String, Object> userMap2 = new HashMap<String, Object>(8) {{
            put("name", "test2");put("sex", "woman");put("job", "worker2");
        }};
        Map<String, Object> userMap3 = new HashMap<String, Object>(8) {{
            put("name", "test3");put("sex", "woman");put("job", "worker2");
        }};
        Map<String, Object> userMap4 = new HashMap<String, Object>(8) {{
            put("name", "test4");put("sex", "man");put("jobpython", "worker3");
        }};
        List<Map<String, Object>> userList = Arrays.asList(userMap1, userMap2, userMap3, userMap4);
        System.out.println(userList);
        // 使用stream流将List转成Map
        Map<String, String> userMap = userList.stream()
                .collect(Collectors.toMap(map1 -> (String) map1.get("name"), 
                    map2 -> (String) map2.get("sex")));
        System.out.println(userMap);
    }
}
-------------打印结果-------------
[{name=test1, job=worker1, sex=man}, {name=test2, job=worker2, sex=woman}, {name=test3, job=worker2, sex=woman}, {name=test4, job=worker3, sex=man}]

{test4=man, test2=woman, test3=woman, test1=man}

List《Map《String, Object》》转Map《String, Map《String, Object》》

由List<Map<String, Object>>转Map<String, Map<String, Object>>操作中，Map中的String也可以是Long、Integer或者其它的类型：

public class MainTest {
    public static void main(String[] args) {
        Map<String, Object> userMap1 = new HashMap<String, Object>(8) {{
            put("name", "test1");put("sex", "man");put("job", "worker1");
        }};
        Map<String, Object> userMap2 = new HashMap<String, Object>(8) {{
            put("name", "test2");put("sex", "woman");put("job", "worker2");
        }};
        Map<String, Object> userMap3 = new HashMap<String, Object>(8) {{
            put("name", "test3");put("sex", "woman");put("job", "worker2");
        }};
        Map<String, Object> userMap4 = new HashMap<String, Object>(8) {{
            put("name", "test4");put("sex", "man");put("job", "worker3");
        }};
        List<Map<String, Object>> userList = Arrays.asList(userMap1, userMap2, userMap3, userMap4);
        System.out.println(userList);
        // 使用stream流将List转成Map
        Map<String, Map<String, Object>> userMap = userList.stream()
        .collect(Collectors.toMap(map1 -> (String) map1.get("name"), map2 -> map2));
        System.out.println(userMap);
    }
}
-------------打印结果-------------
[{name=test1, job=worker1, sex=man}, {name=test2, job=worker2, sex=woman}, 
{name=test3, job=worker2, sex=woman}, {name=test4, job=worker3, sex=man}]


{test4={name=test4, job=worker3, sex=man}, test2={name=test2, job=worker2, sex=woman},
test3={name=test3, job=worker2, sex=woman}, test1={name=test1, job=worker1, sex=man}}

List《Map》转Map《String, List《Map》》

由List转Map>，根据Map中的某个值进行分组：

public class MainTest {
    public static void main(String[] args) {
        Map<String, Object> userMap1 = new HashMap<String, Object>(8) {{
            put("name", "test1");put("sex", "man");put("job", "worker1");
        }};
        Map<String, Object> userMap2 = new HashMap<String, Object>(8) {{
            put("name", "test2");put("sex", "woman");put("job", "worker2");
        }};
        Map<String, Object> userMap3 = new HashMap<String, Object>(8) {{
            put("name", "test3");put("sex", "woman");put("job", "worker2");
        }};
        Map<String, Object> userMap4 = new HashMap<String, Object>(8) {{
            put("name", "test4");put("sex", "man");put("job", "worker3");
        }};
        List<Map<String, Object>> userList = Arrays.asList(userMap1, userMap2, userMap3, userMap4);
        System.out.println(userList);
        // 使用stream流将List转成Map
        Map<String, List<Map<String, Object>>> userMap = userList.stream()
                .collect(Collectors.groupingBy(map1 -> (String) map1.China编程get("sex")));
        System.out.println(userMap);
    }
}
-------------打印结果-------------
[{name=test1, job=worker1, sex=man}, {name=test2, job=worker2, sex=woman}, {name=test3, job=worker2, sex=woman}, {name=test4, job=worker3, sex=man}]
{woman=[{name=test2, job=worker2, sex=woman}, {name=test3, job=worker2, sex=woman}], man=[{name=test1, job=worker1, sex=man}, {name=test4, job=worker3, sex=man}]}

性能说明

需要注意的是Stream使用流处理也是有使用限制的，比如初始化时间和性能限制：

  • 初始化时间：系统第一次使用Stream流的时候初始化时间如果是1W数据以内的需要几十毫秒，如果是10W数据以内的初始化需要100毫秒左右，100W初始化需要1000毫秒左右，1000W初始化则需要2500毫秒左右，而foreach的初始化时间和后续的时间是差不多的；
  • 运行性能：数据量在1W级别以下的时间花费差不多，10W数据以内的Stream流比性能是foreach的1/2，100W数据以内的Stream流性能是foreach的3/5，而到了1000W数据量级下Stream又变成了foreach的一倍左右，foreach到了1000W数据量级下最开始运行时间还保持在1400毫秒左右，到了后面则跑到了6000毫秒甚至7000毫秒，不知道是不是因为GC导致的。

因此使用Stream时适用于低数据量的情况，当数据量级在1W以下是Stream流和foreach都可以使用，性能差别不大；到了10W-100W时应该使用foreach性能更快；而到了1000W量级的情况下就该使用Stream或者其它的大数据解析框架了。

使用上述方式的20次平均运行时间表（仅代表本机I5-8400 2.8Ghz-2.81Ghz的规格CPU运行效率）：

运行方式

数据量级

初始化时间(ms)

初始化后的

平均运行效率(ms)

foreach

1W

38

1

stream流

1W

1

1

foreach

10W

28

6

stream流

10W

54

12

foreach

100W

139

111

stream流

100W

1300

181

foreach

1000W

2500

3500

stream流

1000W

1130

6000

总结

以上为个人经验，希望能给大家一个参考，也希望大家多多支持编程China编程(www.chinasem.cn)。

这篇关于Java使用Stream流的Lambda语法进行List转Map的操作方式的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1154511。

相关文章

Python中注释使用方法举例详解

Python中注释使用方法举例详解

《Python中注释使用方法举例详解》在Python编程语言中注释是必不可少的一部分,它有助于提高代码的可读性和维护性,：本文主要介绍Python中注释使用方法的相关资料,需要的朋友可以参考下... 目录一、前言二、什么是注释？示例：三、单行注释语法：以 China编程# 开头，后面的内容为注释内容示例：示例：四
阅读更多...
mysql表操作与查询功能详解

mysql表操作与查询功能详解

《mysql表操作与查询功能详解》本文系统讲解MySQL表操作与查询,涵盖创建、修改、复制表语法,基本查询结构及WHERE、GROUPBY等子句,本文结合实例代码给大家介绍的非常详细,感兴趣的朋友跟随... 目录01.表的操作1.1表操作概览1.2创建表1.3修改表1.4复制表02.基本查询操作2.1 SE
阅读更多...
SpringBoot整合liteflow的详细过程

SpringBoot整合liteflow的详细过程

《SpringBoot整合liteflow的详细过程》：本文主要介绍SpringBoot整合liteflow的详细过程,本文给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋...  liteflow 是什么？ 能做什么？总之一句话：能帮你规范写代码逻辑 ，编排并解耦业务逻辑，代码
阅读更多...
JavaSE正则表达式用法总结大全

JavaSE正则表达式用法总结大全

《JavaSE正则表达式用法总结大全》正则表达式就是由一些特定的字符组成,代表的是一个规则,：本文主要介绍JavaSE正则表达式用法的相关资料,文中通过代码介绍的非常详细,需要的朋友可以参考下... 目录常用的正则表达式匹配符正则表China编程达式常用的类Pattern类Matcher类PatternSynta
阅读更多...
Spring Security中用户名和密码的验证完整流程

Spring Security中用户名和密码的验证完整流程

《SpringSecurity中用户名和密码的验证完整流程》本文给大家介绍SpringSecurity中用户名和密码的验证完整流程,本文结合实例代码给大家介绍的非常详细,对大家的学习或工作具有一定... 首先创建了一个UsernamePasswordAuthenticationTChina编程oken对象，这是S
阅读更多...
java实现docker镜像上传到harbor仓库的方式

java实现docker镜像上传到harbor仓库的方式

《java实现docker镜像上传到harbor仓库的方式》：本文主要介绍java实现docker镜像上传到harbor仓库的方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地... 目录1. 前 言2. 编写工具类2.1 引入依赖包2.2 使用当前服务器的docker环境推送镜像2.2
阅读更多...
Java easyExcel实现导入多sheet的Excel

Java easyExcel实现导入多sheet的Excel

《JavaeasyExcel实现导入多sheet的Excel》这篇文章主要为大家详细介绍了如何使用JavaeasyExcel实现导入多sheet的Excel,文中的示例代码讲解详细,感兴趣的小伙伴可... 目录1.官网2.Excel样式3.代码1.官网easyExcel官网2.Excel样式3.代码
阅读更多...
Java MQTT实战应用

Java MQTT实战应用

《JavaMQTT实战应用》本文详解MQTT协议,涵盖其发布/订阅机制、低功耗高效特性、三种服务质量等级（QoS0/1/2）,以及客户端、代理、主题的核心概念,最后提供Linux部署教程、Sprin... 目录一、MQTT协议二、MQTT优点三、三种服务质量等级四、客户端、代理、主题1. 客户端（Clien
阅读更多...
Java中调用数据库存储过程的示例代码

Java中调用数据库存储过程的示例代码

《Java中调用数据库存储过程的示例代码》本文介绍Java通过JDBC调用数据库存储过程的方法,涵盖参数类型、执行步骤及数据库差异,需注意异常处理与资源管理,以优化性能并实现复杂业务逻辑,感兴趣的朋友... 目录一、存储过程概述二、Java调用存储过程的基本javascript步骤三、Java调用存储过程示
阅读更多...
Go语言数据库编程GORM 的基本使用详解

Go语言数据库编程GORM 的基本使用详解

《Go语言数据库编程GORM的基本使用详解》GORM是Go语言流行的ORM框架,封装database/sql,支持自动迁移、关联、事务等,提供CRUD、条件查询、钩子函数、日志等功能,简化数据库操作... 目录一、安装与初始化1. 安装 GORM 及数据库驱动2. 建立数据库连接二、定义模型结构体三、自动迁
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2