使用Java Stream，将集合转换为一对一Map

转载 于 2025-12-26 11:30:02 发布 · 16 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：https://www.cnblogs.com/zwwhnly/p/19403765
文章标签：

#it

在日常的开发工作中，我们经常使用到Java Stream，特别是Stream API中提供的Collectors.toList()收集器，

但有些场景下，我们需要将集合转换为Map，这时候就需要使用到Stream API中提供的另一个收集器：

Collectors.toMap，它可以将流中的元素映射为键值对，并收集到一个Map中。

1. 三种主要的重载方法

Collectors.toMap有3种重载方法，分别是：

1)两个参数的重载方法（最简单的形式）

/* by 01130.hk - online tools website : 01130.hk/zh/linuxcmd.html */
public static <T, K, U> Collector<T, ?, Map<K,U>> toMap(Function<? super T, ? extends K> keyMapper,
                                Function<? super T, ? extends U> valueMapper) {
	return toMap(keyMapper, valueMapper, throwingMerger(), HashMap::new);
}

2)三个参数的重载方法（包含冲突处理）

/* by 01130.hk - online tools website : 01130.hk/zh/linuxcmd.html */
public static <T, K, U> Collector<T, ?, Map<K,U>> toMap(Function<? super T, ? extends K> keyMapper,
                                Function<? super T, ? extends U> valueMapper,
                                BinaryOperator<U> mergeFunction) {
    return toMap(keyMapper, valueMapper, mergeFunction, HashMap::new);
}

3)四个参数的重载方法（指定Map实现）

public static <T, K, U, M extends Map<K, U>>
   Collector<T, ?, M> toMap(Function<? super T, ? extends K> keyMapper,
                            Function<? super T, ? extends U> valueMapper,
                            BinaryOperator<U> mergeFunction,
                            Supplier<M> mapSupplier) {
    BiConsumer<M, T> accumulator
            = (map, element) -> map.merge(keyMapper.apply(element),
                                          valueMapper.apply(element), mergeFunction);
    return new CollectorImpl<>(mapSupplier, accumulator, mapMerger(mergeFunction), CH_ID);
}

接下来，我们结合使用示例详细讲解。

2. 使用示例

2.1 将对象的某些属性转换为Map

假设有一个城市列表，需要将其转换为Map，其中Key为城市ID、Value为城市名称，转换方法如下所示：

@Getter
@Setter
public class City {
    private Integer cityId;

    private String cityName;

    public City(Integer cityId, String cityName) {
        this.cityId = cityId;
        this.cityName = cityName;
    }
}

List<City> cityList = Arrays.asList(
        new City(1, "北京"),
        new City(2, "上海"),
        new City(3, "广州"),
        new City(4, "深圳")
);
Map<Integer, String> cityMap = cityList.stream()
        .collect(Collectors.toMap(City::getCityId, City::getCityName));
System.out.println(cityMap);

输出结果：

2.2 将对象列表转换为Map（ID -> 对象）

仍然使用上面的城市列表，需要将其转换为Map，其中Key为城市ID、Value为城市对象，转换方法如下所示：

List<City> cityList = Arrays.asList(
        new City(1, "北京"),
        new City(2, "上海"),
        new City(3, "广州"),
        new City(4, "深圳")
);
Map<Integer, City> cityMap = cityList.stream()
        .collect(Collectors.toMap(City::getCityId, city -> city));
City city = cityMap.get(1);
System.out.println("城市ID: " + city.getCityId());
System.out.println("城市名称: " + city.getCityName());

输出结果如下所示：

城市ID: 1
城市名称: 北京

上面的写法等价于：

Map<Integer, City> cityMap = cityList.stream()
    	.collect(Collectors.toMap(City::getCityId, Function.identity()));

因为Function.identity()内部实现是下面这样的：

static <T> Function<T, T> identity() {
    return t -> t;
}

2.3 键冲突处理

假设上面的城市列表中有一个ID重复的城市：

List<City> cityList = Arrays.asList(
        new City(1, "北京"),
        new City(2, "上海"),
        new City(3, "广州"),
        new City(4, "深圳"),
        new City(4, "天津")
);
Map<Integer, String> cityMap = cityList.stream()
        .collect(Collectors.toMap(City::getCityId, City::getCityName));
System.out.println("城市ID: 4, 城市名称: " + cityMap.get(4));

此时运行代码，会抛出java.lang.IllegalStateException异常，如下图所示：

有3种常见的键冲突处理方式，分别是保留旧值、使用新值和合并值，接下来一一讲解。

1)方式一：保留旧值

Map<Integer, String> cityMap = cityList.stream()
        .collect(Collectors.toMap(City::getCityId, City::getCityName, (oldValue, newValue) -> oldValue));

输出结果：

城市ID: 4, 城市名称: 深圳

2)方式二：使用新值

Map<Integer, String> cityMap = cityList.stream()
        .collect(Collectors.toMap(City::getCityId, City::getCityName, (oldValue, newValue) -> newValue));

输出结果：

城市ID: 4, 城市名称: 天津

3)方式三：合并值

Map<Integer, String> cityMap = cityList.stream()
        .collect(Collectors.toMap(City::getCityId, City::getCityName, 
        		(oldValue, newValue) -> oldValue + ", " + newValue));

输出结果：

城市ID: 4, 城市名称: 深圳, 天津

2.4 数据分组聚合

假设有一个销售记录列表，需要将其转换为Map，其中Key为销售员、Value为该销售员的总销售额，转换方法如下所示：

@Getter
@Setter
public class SalesRecord {
    private String salesPerson;

    private BigDecimal amount;

    public SalesRecord(String salesPerson, BigDecimal amount) {
        this.salesPerson = salesPerson;
        this.amount = amount;
    }
}

List<SalesRecord> salesRecordList = Arrays.asList(
        new SalesRecord("张三", new BigDecimal("1000")),
        new SalesRecord("李四", new BigDecimal("2000")),
        new SalesRecord("张三", new BigDecimal("980"))
);

Map<String, BigDecimal> salesRecordMap = salesRecordList.stream()
        .collect(Collectors.toMap(SalesRecord::getSalesPerson, SalesRecord::getAmount, BigDecimal::add));
System.out.println(salesRecordMap);

输出结果：

上面的例子是销售额累加，也可以只取最小值：

Map<String, BigDecimal> salesRecordMap = salesRecordList.stream()
        .collect(Collectors.toMap(SalesRecord::getSalesPerson, SalesRecord::getAmount, BigDecimal::min));

此时的输出结果：

或者只取最大值：

Map<String, BigDecimal> salesRecordMap = salesRecordList.stream()
        .collect(Collectors.toMap(SalesRecord::getSalesPerson, SalesRecord::getAmount, BigDecimal::max));

此时的输出结果：

2.5 指定Map实现

默认情况下，Collectors.toMap是将结果收集到HashMap中，如果有需要，我们也可以指定成TreeMap或者LinkedHashMap。

如果想要保持插入顺序，可以指定使用LinkedHashMap：

List<City> cityList = Arrays.asList(
        new City(2, "上海"),
        new City(1, "北京"),
        new City(4, "深圳"),
        new City(3, "广州")
);
Map<Integer, String> cityMap = cityList.stream()
        .collect(Collectors.toMap(City::getCityId, City::getCityName,
                (existing, replacement) -> existing, LinkedHashMap::new));
System.out.println(cityMap);

输出结果：

如果想要按键排序，可以指定使用TreeMap：

List<City> cityList = Arrays.asList(
        new City(2, "上海"),
        new City(1, "北京"),
        new City(4, "深圳"),
        new City(3, "广州")
);
Map<Integer, String> cityMap = cityList.stream()
        .collect(Collectors.toMap(City::getCityId, City::getCityName,
                (existing, replacement) -> existing, TreeMap::new));
System.out.println(cityMap);

输出结果：

3. 注意事项

3.1 空异常

如果valueMapper中取出的值有null值，会抛出java.lang.NullPointerException异常，如下示例：

List<City> cityList = Arrays.asList(
        new City(1, "北京"),
        new City(2, "上海"),
        new City(3, "广州"),
        new City(4, "深圳"),
        new City(5, null)
);
Map<Integer, String> cityMap = cityList.stream()
        .collect(Collectors.toMap(City::getCityId, City::getCityName));
System.out.println(cityMap);

运行以上代码会抛出异常，如下图所示：

有两种解决方案，第一种解决方案是过滤null值：

Map<Integer, String> cityMap = cityList.stream()
        .filter(city -> city.getCityName() != null)
        .collect(Collectors.toMap(City::getCityId, City::getCityName));

第二种解决方案是提供默认值：

Map<Integer, String> cityMap = cityList.stream()
        .collect(Collectors.toMap(City::getCityId,
                city -> Optional.ofNullable(city.getCityName()).orElse("未知")));

3.2 键重复异常

如果出现重复键，且没有提供mergeFunction参数，会抛出java.lang.IllegalStateException异常，如下示例：

List<City> cityList = Arrays.asList(
        new City(1, "北京"),
        new City(2, "上海"),
        new City(3, "广州"),
        new City(4, "深圳"),
        new City(4, "天津")
);
Map<Integer, String> cityMap = cityList.stream()
        .collect(Collectors.toMap(City::getCityId, City::getCityName));
System.out.println(cityMap);

运行以上代码会抛出异常，如下图所示：

解决方案见本篇文章2.3 键冲突处理部分。

4. 总结

Collectors.toMap是Stream API中提供的一个非常方便的收集器，它可以将流中的元素映射为键值对，并收集到一个Map中。

它适用于一对一映射的场景，但在使用时，要注意避免java.lang.NullPointerException异常和

java.lang.IllegalStateException异常。

文章持续更新，欢迎关注微信公众号「申城异乡人」第一时间阅读！

cmdos
关注
Java8中利用stream对map集合进行过滤的方法
08-27
本文将详细介绍如何使用Stream对Map集合进行过滤，包括使用filter方法过滤null和空字符串，以及使用map方法对元素进行转换操作，并使用collect方法对结果进行聚合。 首先，让我们来看一下传统的处理方式。在处理Map...
在Java 8中将List转换为Map对象方法
08-26
在Java 8中，将List转换为Map对象是一种非常实用的技术，特别是在处理大规模数据时非常有用。本文将详细介绍在Java 8中将List转换为Map对象的方法，并提供了多种实现方式。 首先，我们需要明确Map的key是什么？在这...
java 集合对象转map的几种方式（stream流）
ning0er的博客
03-31 1万+
例如： public class User { private Integer id; private String name; public User(Integer id, String name) { this.id = id; this.name = name; } } 把User集合转成key ->id ,value->User对象的map 1.最原始方法 List<Us
Java 集合List转 Map 和Map转List的方法总结（举例说明!）
白白白鲤鱼的博客
05-31 2万+
Java 集合List转 Map 和Map转List的方法总结
java集合 list转map一些常用的方式（Stream流，，，）
qq_46703281的博客
09-12 1万+
这片文章是用来整理开发中经常用到的一些集合之间的转换方法（stream流 List 转Map），作为笔记，提高开发效率，有需要的小伙伴可以参考一下，这片文章会慢慢补充完整。
Java对象集合按某个字段转为map
congge_study的博客
01-22 4358
Java对象集合按照个字段转为map
java如何将对象转换为map？如何将map转换为对象？
weixin_43394692的博客
04-24 7547
手动转换的方式是最基本的一种转换方式，通过获取对象的属性值，创建 Map 对象并把属性存入 Map 对象中，或者从 Map 对象中获取值，创建对象并把属性值赋值给对象。Gson 是 Google 提供的一个 Java 库，可以将 Java 对象转换成 Json 字符串，也可以将 Json 字符串转换成 Java 对象。Jackson 是另一个流行的 JSON 库，可以将 Java 对象转换成 Json 字符串，也可以将 Json 字符串转换成 Java 对象。
Java8处理集合的优雅姿势之Stream
08-26
* 通过已有的集合来创建流：可以使用集合的stream方法将一个集合转换成流。 * 通过Stream创建流：可以使用Stream类提供的方法，直接返回一个由指定元素组成的流。 Stream中间操作 Stream有很多中间操作，多个中间...
精选资源
java使用stream对日期排序
11-17
如果日期与非日期数据混合在一起，可以使用`map()`函数将非日期数据转换为日期，然后进行排序： ```java List<MyObject> objects = ...; // 包含日期字段的列表 List<MyObject> sortedObjects = objects.stream...
如何利用Java8 Stream API对Map按键或值排序
08-25
Java 8 Stream API 的引入为处理集合数据提供了更高效、更简洁的方式，其中包括对Map的排序功能。在本文中，我们将深入探讨如何使用Stream API来按键或值对Map进行排序，以及涉及的一些关键函数和概念。 一、Java 8...
Java 8 Stream处理List和Map之间的转换
先知三日
10-30 3562
Stream（流）是一个来自数据源的元素队列并支持聚合操作元素是特定类型的对象，形成一个队列。Java中的Stream并不会存储元素，而是按需计算。数据源流的来源。可以是集合，数组，I/O channel， 产生器generator 等。聚合操作类似SQL语句一样的操作， 比如filter, map, reduce, find, match, sorted等。Pipelining: 中间操作都会返回流对象本身。
实现Java对象和Map之间相互转换的常用5种方法
tigerhhzz的博客
10-08 5945
在Java开发中，经常需要将Java对象转换成Map，或者反过来将Map转换成Java对象。这种转换在很多场景下都非常有用，比如在序列化和反序列化过程中、在数据传输和持久化时、或者在进行对象属性的批量操作时。本文将介绍几种不同的方法来实现Java对象和Map之间的相互转换，选择哪种方法取决于项目的具体需求和个人偏好。
Java 对象转化为Map
MYians的博客
12-15 1786
方式一: 利用fastjson 把对象转化为map 1.项目引入依赖 <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson --> <dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</artifactId>
Java对象与Map转换，你了解几种？
7me
09-26 1万+
开发小伙伴们通常会需要使用到对象和Map互相转换的开发场景，本文主要介绍6种方式，欲知详情，请问下文分解。
Java中List转Map的几种方式
默慊的博客
12-27 2万+
在List转Map的过程中，我们可以选择使用for循环遍历、Java8 Stream API、Apache Commons Collections或Google Guava。对于小规模数据集，使用for循环遍历是最简单直接的方式。而对于大规模数据集，Java8 Stream API提供了更高效和优雅的实现方式。如果你使用了Apache Commons Collections或Google Guava这些类库，则可以利用它们提供的工具方法简化代码。选择合适的方式取决于实际需求和项目环境。
Java对象和Map互相转换的6种方式
热门推荐
wy971744839的博客
04-22 3万+
开发小伙伴们通常会需要使用到对象和Map互相转换的开发场景，本文主要介绍6种方式，欲知详情，请问下文分解。
Java 将对象转为 Map 的几种方法
长安明月的博客
04-21 848
可以先将对象序列化为 JSON 字符串，然后再将该字符串反序列化为 Map 对象。Guava 不直接支持对象到 Map 的转换，需要手动创建 Map 并填充数据。Hutool 有一个 BeanUtil 类可以直接将对象转换为 Map。在 Java 开发中，有时需要将对象转为 Map，以下是几种方式。二、对象转为 Map 的几种方式。2.1 使用 Jackson。2.4 使用 Hutool。一、Java 对象示例。2.3 使用 Guava。2.2 使用 Gson。
java8 对集合对象 按字段 转为Map
weixin_36864782的博客
07-27 675
Java 8 中集合对象按字段转为 Map 的实现 作为一名经验丰富的开发者，我很高兴能够帮助刚入行的小白们。在 Java 8 中，我们经常需要将集合对象转换为 Map，以便更方便地进行数据操作。本文将详细介绍如何实现这一功能。 流程概述 首先，我们通过一个简单的表格来概述整个流程： 步骤 描述 1 定义源集...
java 类型转换，集合对象转map
WYT11的博客
07-07 169
集合对象转map。
java stream 将集合转换为map
最新发布
12-04
<think> 首先，用户的问题是：“我想查找使用Java Stream将集合转换为Map的方法 请问使用Java Stream将集合转换为Map的实现方法”。他们提供了几个引用，这些引用似乎是从之前的上下文或站内引用来的，涉及到Java Stream API的使用，特别是map方法和Collectors.toMap()。 关键点： - 用户想要知道如何使用Java Stream将集合转换为Map。 - 引用[3]和[5]直接提到了使用Collectors.toMap()。 - 引用[4]讨论了生产级实现中的细节。 - 引用[1]和[2]是关于map方法的一般使用。 系统指令： - 所有行内数学表达式使用$...$格式（但这里可能不涉及数学，所以可能不需要）。 - 独立公式使用$$...$$格式（同样，可能不适用）。 - LaTeX语法正确（在代码块中，不需要LaTeX）。 - 使用中文回答。 - 生成相关问题。 - 回答中引用的段落末尾自然地添加引用标识，如[^1]。 - 用户可见层：回答结构清晰，逐步解决问题，保证真实可靠。 - 最后添加相关问题。 我的回答需要： 1. 结构化：逐步解释如何实现。 2. 真实可靠：基于Java标准库，参考提供的引用。 3. 使用中文。 4. 在引用段落末尾添加引用标识。 5. 生成相关问题。 核心方法是使用Java Stream API的Collectors.toMap()方法。步骤： - 开始一个Stream（例如，list.stream()）。 - 使用collect(Collectors.toMap(keyMapper, valueMapper))。 - 处理键冲突（可选）。 - 处理null值（可选）。 从引用中： - [3]给出了一个示例代码。 - [4]讨论了生产级细节如键冲突。 - [5]展示了简单的一行代码转换。 回答结构： 1. 介绍方法：简要说明使用Stream API转换集合为Map。 2. 基本步骤：解释如何做。 3. 提供示例代码：基于引用[3]或[5]。 4. 讨论注意事项：如键冲突、null处理。 5. 添加引用：在相关部分添加标识。 6. 生成相关问题。 示例代码： 从引用[3]： ```java import java.util.*; import java.util.stream.Collectors; public class Main { public static void main(String[] args) { List<Person> people = Arrays.asList( new Person("Alice", 25), new Person("Bob", 30), new Person("Charlie", 35) ); Map<String, Integer> ageByName = people.stream() .collect(Collectors.toMap(Person::getName, Person::getAge)); System.out.println(ageByName); } } class Person { private String name; private int age; // constructors, getters, etc. } ``` 注意事项： - 键冲突：如果键重复，会抛出IllegalStateException。可以使用第三个参数来解决冲突，如(toMap(key, value, mergeFunction))。 - null键：可能抛出NullPointerException，需要处理。 - Map实现：默认是HashMap，可以使用第四个参数指定，如LinkedHashMap。 生成相关问题： 基于主题，如“如何处理键冲突？”、“如何转换复杂对象？”等。 最终回答结构： - 开头介绍。 - 步骤解释。 - 代码示例。 - 注意事项。 - 相关问题。 </think> ### 使用 Java Stream 将集合转换为 Map 的实现方法 在 Java 中，使用 Stream API 将集合（如 List）转换为 Map 是一种高效且优雅的方式，主要通过 `Collectors.toMap()` 方法实现。以下是详细步骤和示例，确保代码可靠且适用于生产环境。 #### 1. **基本实现步骤** - **步骤 1**: 将集合转换为 Stream，例如 `list.stream()`。 - **步骤 2**: 使用 `collect(Collectors.toMap(...))` 方法： - **参数 1 (键提取器)**: 指定 Map 的键如何从元素中提取，例如 `Person::getName`。 - **参数 2 (值提取器)**: 指定 Map 的值如何从元素中提取，例如 `Person::getAge`。 - **步骤 3**: 处理结果，例如收集到 Map 变量中。 - 这种方法简洁易读，特别适用于对象属性到 Map 的转换[^2]。 #### 2. **基础代码示例** 参考引用[3]，以下是一个简单示例，将 `List<Person>` 转换为 `Map<String, Integer>`（键为姓名，值为年龄）： ```java import java.util.*; import java.util.stream.Collectors; public class Main { public static void main(String[] args) { // 创建示例集合 List<Person> people = Arrays.asList( new Person("Alice", 25), new Person("Bob", 30), new Person("Charlie", 35) ); // 使用 Stream 转换为 Map Map<String, Integer> ageByName = people.stream() .collect(Collectors.toMap( Person::getName, // 键提取器 Person::getAge // 值提取器 )); System.out.println(ageByName); // 输出: {Alice=25, Bob=30, Charlie=35} } } class Person { private String name; private int age; public Person(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public int getAge() { return age; } } ``` 此代码通过 `Person::getName` 和 `Person::getAge` 提取键值对，生成一个 `HashMap`[^3]。 #### 3. **生产级注意事项** 在实际应用中，需处理潜在问题以确保健壮性： - **键冲突处理**: 如果键重复（如两个 `Person` 同名），会抛出 `IllegalStateException`。添加第三个参数（合并函数）解决： ```java Map<String, Integer> ageByName = people.stream() .collect(Collectors.toMap( Person::getName, Person::getAge, (oldValue, newValue) -> oldValue // 保留旧值，或自定义逻辑如 newValue )); ``` [^4] - **空值处理**: 如果键或值为 `null`，可能引发 `NullPointerException`。提前过滤或使用 `Optional`： ```java Map<String, Integer> safeMap = people.stream() .filter(p -> p.getName() != null) // 过滤空键 .collect(Collectors.toMap(Person::getName, Person::getAge)); ``` - **指定 Map 类型**: 默认生成 `HashMap`，可通过第四个参数指定其他实现（如 `LinkedHashMap` 保持顺序）： ```java Map<String, Integer> orderedMap = people.stream() .collect(Collectors.toMap( Person::getName, Person::getAge, (oldVal, newVal) -> oldVal, LinkedHashMap::new )); ``` [^4] - **对象直接作为值**: 如果需要整个对象作为值（例如 `Map<Integer, Person>`），使用 `Function.identity()`： ```java Map<Integer, Person> idToPerson = people.stream() .collect(Collectors.toMap(Person::getAge, Function.identity())); ``` [^5] #### 4. **优势与适用场景** - **优势**: 代码简洁（一行完成转换），易于维护，且 Stream API 支持链式操作（如过滤、映射后再转换）[^1][^2]。 - **典型场景**: - 数据库查询结果（如 MyBatis/Hibernate 返回的 List）转 Map，便于通过 ID 快速检索[^5]。 - 数据分组或聚合（如按类别统计）。 - API 响应中简化数据结构。 通过以上方法，您可以高效地将集合转换为 Map，同时处理生产环境中的常见问题。确保在键可能重复或含空值时添加防御性逻辑[^4]。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值