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。

相关文章

一篇文章彻底搞懂macOS如何决定java环境

一篇文章彻底搞懂macOS如何决定java环境

《一篇文章彻底搞懂macOS如何决定java环境》MacOS作为一个功能强大的操作系统,为开发者提供了丰富的开发工具和框架,下面：本文主要介绍macOS如何决定java环境的相关资料,文中通过代码... 目录方法一：使用 which命令方法二：使用 Java_home工具（Apple 官方推荐）那问题来了，
阅读更多...
Java HashMap的底层实现原理深度解析

Java HashMap的底层实现原理深度解析

《JavaHashMap的底层实现原理深度解析》HashMap基于数组+链表+红黑树结构,通过哈希算法和扩容机制优化性能,负载因子与树化阈值平衡效率,是Java开发必备的高效数据结构,本文给大家介绍... 目录一、概述：HashMap的宏观结构二、核心数据结构解析1. 数组（桶数组）2. 链表节点（Node
阅读更多...
Java AOP面向切面编程的概念和实现方式

Java AOP面向切面编程的概念和实现方式

《JavaAOP面向切面编程的概念和实现方式》AOP是面向切面编程,通过动态代理将横切关注点（如日志、事务）与核心业务逻辑分离,提升代码复用性和可维护性,本文给大家介绍JavaAOP面向切面编程的概... 目录一、AOP 是什么？二、AOP 的核心概念与实现方式核心概念实现方式三、Spring AOP 的关
阅读更多...
详解SpringBoot+Ehcache使用示例

详解SpringBoot+Ehcache使用示例

《详解SpringBoot+Ehcache使用示例》本文介绍了SpringBoot中配置Ehcache、自定义get/set方式,并实际使用缓存的过程,文中通过示例代码介绍的非常详细,对大家的学习或者... 目录摘要概念内存与磁盘持久化存储：配置灵活性：编码示例引入依赖：配置ehcache.XML文件：配置
阅读更多...
Java 虚拟线程的创建与使用深度解析

Java 虚拟线程的创建与使用深度解析

《Java虚拟线程的创建与使用深度解析》虚拟线程是Java19中以预览特性形式引入,Java21起正式发布的轻量级线程,本文给大家介绍Java虚拟线程的创建与使用,感兴趣的朋友一起看看吧... 目录一、虚拟线程简介1.1 什么是虚拟线程？1.2 为什么需要虚拟线程？二、虚拟线程与平台线程对比代码对比示例：三
阅读更多...
k8s按需创建PV和使用PVC详解

k8s按需创建PV和使用PVC详解

《k8s按需创建PV和使用PVC详解》Kubernetes中,PV和PVC用于管理持久存储,StorageClass实现动态PV分配,PVC声明存储需求并绑定PV,通过kubectl验证状态,注意回收... 目录1.按需创建 PV（使用 StorageClass）创建 StorageClass2.创建 PV
阅读更多...
Redis 基本数据类型和使用详解

Redis 基本数据类型和使用详解

《Redis基本数据类型和使用详解》String是Redis最基本的数据类型,一个键对应一个值,它的功能十分强大,可以存储字符串、整数、浮点数等多种数据格式,本文给大家介绍Redis基本数据类型和... 目录一、Redis 入门介绍二、Redis 的五大基本数据类型2.1 String 类型2.2 Hash
阅读更多...
Java中的.close()举例详解

Java中的.close()举例详解

《Java中的.close()举例详解》.close()方法只适用于通过window.open()打开的弹出窗口,对于浏览器的主窗口,如果没有得到用户允许是不能关闭的,：本文主要介绍Java中的.... 目录当你遇到以下三种情况时，一定要记得使用 .close()：用法作用举例如何判断代码中的 input
阅读更多...
Redis中Hash从使用过程到原理说明

Redis中Hash从使用过程到原理说明

《Redis中Hash从使用过程到原理说明》RedisHash结构用于存储字段-值对,适合对象数据,支持HSET、HGET等命令,采用ziplist或hashtable编码,通过渐进式rehash优化... 目录一、开篇：Hash就像超市的货架二、Hash的基本使用1. 常用命令示例2. Java操作示例三
阅读更多...
Linux创建服务使用systemctl管理详解

Linux创建服务使用systemctl管理详解

《Linux创建服务使用systemctl管理详解》文章指导在Linux中创建systemd服务,设置文件权限为所有者读写、其他只读,重新加载配置,启动服务并检查状态,确保服务正常运行,关键步骤包括权... 目录创建服务 /usr/lib/systemd/system/设置服务文件权限：所有者读写js，其他
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2