17370845950

问题描述与目标

在java开发中，我们经常需要对数据结构进行转换以适应不同的业务需求。假设我们有一个map>，其中键（string）代表项目名称，值（list）是参与该项目的用户列表。例如：

Map> map = new HashMap<>();
map.put("projectA", Arrays.asList(new User(1,"Bob"), new User(2,"John"), new User(3,"Mo")));
map.put("projectB", Arrays.asList(new User(2,"John"), new User(3,"Mo")));
map.put("projectC", Arrays.asList(new User(3,"Mo")));

我们的目标是将这个Map转换为Map>，其中键是独立的用户对象，值是该用户所参与的所有项目名称列表。期望的输出结果类似：

Bob  = [projectA]
John = [projectA, projectB]
Mo   = [projectA, projectB, projectC]

这本质上是将一个“项目-用户”的多对一关系，反向转换为“用户-项目”的一对多关系。

用户实体定义

为了更好地表示用户，我们首先定义一个User类。在Java 16及以上版本中，可以使用record来简洁地定义不可变的数据类。

public record User(int id, String name) {}

如果使用Java 8-15，你需要定义一个普通的类，并确保正确实现equals()和hashCode()方法，这对于将User对象用作Map的键至关重要。

// Java 8-15 示例
public class User {
    private int id;
    private String name;

    public User(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() { return id; }
    public String getName() { return name; }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return id == user.id && Objects.equals(name, user.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, name);
    }

    @Override
    public String toString() {
        return "User[id=" + id + ", name=" + name + "]";
    }
}

解决方案一：传统迭代法

最直接的解决方案是使用嵌套循环遍历原始Map的每个条目及其内部的用户列表。

实现思路：

1. 创建一个新的Map>作为结果容器。
2. 遍历原始Map的每个Map.Entry>。Entry的键是项目名称，值是用户列表。
3. 对于每个项目，再遍历其关联的用户列表中的每个User对象。
4. 对于每个User，检查结果Map中是否已经存在该用户作为键。
   • 如果不存在，则使用putIfAbsent()方法将该用户作为键，并初始化一个空的ArrayList作为其值。
   • 然后，将当前的项目名称添加到该用户对应的项目列表中。

代码示例：

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

public class MapTransformation {

    // User record (Java 16+)
    public static record User(int id, String name) {}

    public static void main(String[] args) {
        Map> projectUserMap = new HashMap<>();
        projectUserMap.put("projectA", Arrays.asList(new User(1,"Bob"), new User(2,"John"), new User(3,"Mo")));
        projectUserMap.put("projectB", Arrays.asList(new User(2,"John"), new User(3,"Mo")));
        projectUserMap.put("projectC", Arrays.asList(new User(3,"Mo")));

        Map> userProjectMap = new HashMap<>();

        for (Map.Entry> entry : projectUserMap.entrySet()) {
            String projectName = entry.getKey();
            List users = entry.getValue();

            for (User user : users) {
                // 如果用户不在结果Map中，则为其创建一个新的项目列表
                userProjectMap.putIfAbsent(user, new ArrayList<>());
                // 将当前项目添加到该用户的项目列表中
                userProjectMap.get(user).add(projectName);
            }
        }

        System.out.println("传统迭代法结果:");
        System.out.println(userProjectMap);
    }
}

输出示例：

传统迭代法结果:
{User[id=1, name=Bob]=[projectA], User[id=2, name=John]=[projectA, projectB], User[id=3, name=Mo]=[projectA, projectB, projectC]}

解决方案二：Java Stream API

Java 8引入的Stream API提供了一种更函数式和声明式的方式来处理集合数据。通过结合flatMap和Collectors.groupingBy，我们可以实现相同的转换，代码通常更简洁。

实现思路：

1. 获取原始Map的entrySet()并转换为Stream。
2. 使用flatMap操作将每个Map.Entry>（项目名 -> 用户列表）扁平化为一系列Map.Entry（用户 -> 项目名）对。
   • 对于原始Map的每个条目，我们遍历其用户列表。
   • 对于列表中的每个用户，我们创建一个新的Map.Entry，其中键是用户，值是当前项目名称。
3. 使用Collectors.groupingBy()对扁平化后的流进行分组。
   • 根据Map.Entry的键（即User对象）进行分组。
   • 使用Collectors.mapping()将每个组中的Map.Entry的值（即项目名称）收集到一个List中。

代码示例：

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

public class MapTransformationStream {

    public static record User(int id, String name) {}

    public static void main(String[] args) {
        Map> projectUserMap = new HashMap<>();
        projectUserMap.put("projectA", Arrays.asList(new User(1,"Bob"), new User(2,"John"), new User(3,"Mo")));
        projectUserMap.put("projectB", Arrays.asList(new User(2,"John"), new User(3,"Mo")));
        projectUserMap.put("projectC", Arrays.asList(new User(3,"Mo")));

        Map> userProjectMapStream = projectUserMap.entrySet().stream()
            .flatMap(entry -> entry.getValue().stream() // 扁平化用户列表
                .map(user -> Map.entry(user, entry.getKey()))) // 为每个用户创建 (用户, 项目名) 对
            .collect(Collectors.groupingBy(
                Map.Entry::getKey, // 以User作为分组键
                Collectors.mapping(Map.Entry::getValue, Collectors.toList()) // 将项目名收集到List中
            ));

        System.out.println("Stream API法结果:");
        System.out.println(userProjectMapStream);
    }
}

输出示例：

Stream API法结果:
{User[id=1, name=Bob]=[projectA], User[id=2, name=John]=[projectA, projectB], User[id=3, name=Mo]=[projectA, projectB, projectC]}

关键注意事项

1. equals()和hashCode()的重要性： 无论采用哪种方法，如果将自定义对象（如User）用作Map的键，那么正确实现其equals()和hashCode()方法是至关重要的。HashMap依赖这两个方法来确定两个键是否相等以及它们的存储位置。record类型会自动生成这两个方法，确保基于字段值的相等性判断。
2. 性能考量： 对于小到中等规模的数据集，两种方法在性能上通常没有显著差异。对于非常大的数据集，Stream API在某些情况下可能提供更好的可读性和并行处理的潜力（通过parallelStream()），但并非总是性能最优解，具体取决于操作的性质。
3. 可读性与维护： Stream API的解决方案通常更简洁、更具声明性，但对于不熟悉函数式编程的开发者来说，传统迭代法可能更容易理解和调试。选择哪种方法取决于团队的偏好和项目的具体要求。

总结

本教程展示了两种在Java中将Map>转换为Map>的有效方法：传统的迭代法和现代的Stream API法。两种方法都能成功实现数据的重组，关键在于理解其背后的逻辑和数据流。在实际开发中，应根据项目需求、团队熟悉度以及性能考量来选择最合适的实现方式，并始终注意自定义对象作为Map键时equals()和hashCode()方法的正确实现。