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

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

本文主要是介绍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。

相关文章

Java中的getBytes()方法使用详解

Java中的getBytes()方法使用详解

《Java中的getBytes()方法使用详解》：本文主要介绍Java中getBytes()方法使用的相关资料,getBytes()方法有多个重载形式,可以根据需要指定字符集来进行转换,文中通过代... 目录前言一、常见重载形式二、示例代码三、getBytes(Charset charset)和getByt
阅读更多...
Spring框架中@Lazy延迟加载原理和使用详解

Spring框架中@Lazy延迟加载原理和使用详解

《Spring框架中@Lazy延迟加载原理和使用详解》：本文主要介绍Spring框架中@Lazy延迟加载原理和使用方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐... 目录一、@Lazy延迟加载原理1.延迟加载原理1.1 @Lazy三种配置方法1.2 @Component
阅读更多...
使用easy connect之后,maven无法使用,原来需要配置-Djava.net.preferIPv4Stack=true问题

使用easy connect之后,maven无法使用,原来需要配置-Djava.net.preferIPv4Stack=true问题

《使用easyconnect之后,maven无法使用,原来需要配置-Djava.net.preferIPv4Stack=true问题》：本文主要介绍使用easyconnect之后,maven无法... 目录使用easGWowCy connect之后,maven无法使用,原来需要配置-DJava.net.pr
阅读更多...
idea报错java: 非法字符: ‘\ufeff‘的解决步骤以及说明

idea报错java: 非法字符: ‘\ufeff‘的解决步骤以及说明

《idea报错java:非法字符:‘ufeff‘的解决步骤以及说明》：本文主要介绍idea报错java:非法字符:ufeff的解决步骤以及说明,文章详细解释了为什么在Java中会出现uf... 目录BOM是什么？1. BOM的作用2. 为什么会出现 \ufeff 错误？3. 如何解决 \ufeff 问题？最
阅读更多...
使用Java编写一个字符脱敏工具类

使用Java编写一个字符脱敏工具类

《使用Java编写一个字符脱敏工具类》这篇文章主要为大家详细介绍了如何使用Java编写一个字符脱敏工具类,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 目录1、字符脱敏工具类2、测试工具类3、测试结果1、字符脱敏工具类import lombok.extern.slf4j.Slf4j
阅读更多...
Java实现按字节长度截取字符串

Java实现按字节长度截取字符串

《Java实现按字节长度截取字符串》在Java中,由于字符串可能包含多字节字符,直接按字节长度截取可能会导致乱码或截取不准确的问题,下面我们就来看看几种按字节长度截取字符串的方法吧... 目录方法一：使用String的getBytes方法方法二：指定字符编码处理方法三：更精确的字符编码处理使用示例注意事项方
阅读更多...
pandas DataFrame keys的使用小结

pandas DataFrame keys的使用小结

《pandasDataFramekeys的使用小结》pandas.DataFrame.keys()方法返回DataFrame的列名,类似于字典的键,本文主要介绍了pandasDataFrameke... 目录Pandas2.2 DataFrameIndexing, iterationpandas.DataF
阅读更多...
使用Python和PaddleOCR实现图文识别的代码和步骤

使用Python和PaddleOCR实现图文识别的代码和步骤

《使用Python和PaddleOCR实现图文识别的代码和步骤》在当今数字化时代,图文识别技术的应用越来越广泛,如文档数字化、信息提取等,PaddleOCR是百度开源的一款强大的OCR工具包,它集成了... 目录一、引言二、环境准备2.1 安装 python2.2 安装 PaddlePaddle2.3 安装
阅读更多...
嵌入式Linux之使用设备树驱动GPIO的实现方式

嵌入式Linux之使用设备树驱动GPIO的实现方式

《嵌入式Linux之使用设备树驱动GPIO的实现方式》：本文主要介绍嵌入式Linux之使用设备树驱动GPIO的实现方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐... 目录一、设备树配置1.1 添加 pinctrl 节点1.2 添加 LED 设备节点二、编写驱动程序2.1
阅读更多...
Spring三级缓存解决循环依赖的解析过程

Spring三级缓存解决循环依赖的解析过程

《Spring三级缓存解决循环依赖的解析过程》：本文主要介绍Spring三级缓存解决循环依赖的解析过程,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录一、循环依赖场景二、三级缓存定义三、解决流程（以ServiceA和ServiceB为例）四、关键机制详解五、设计约
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2