Java8：list转Map

小故事

最近项目中，因为业务需要，我使用了for循环进行List转Map，项目经理看到了，深深的”鄙视“了我，说你怎么写这么古老的写法，一点不优雅。于是我就想到了Java8的新特性，使用stream流进行操作，让代码一下子优雅起来了。

当我们处理一些数据时，将一个列表转换为映射是一个常见的需求。在Java 8中，我们可以使用stream和Lambda表达式、来轻松地将列表转换为映射。在这篇博客文章中，我们将学习如何使用Java 8将List转换为Map。

让我们先来看一个简单的例子，假设我们有一个ApplicationVO类，该类具有id和name属性

古老的for循环

// 需要操作的对象

@Data
public class ApplicationVO {

    // 项目id（唯一）
    private String appId;

    // 项目名
    private String name;

    // 业务字段 ...

    public ApplicationVO() {}

    public ApplicationVO(String appId, String name) {
        this.appId = appId;
        this.name = name;
    }
}

// service层代码
// 先看看我的”上古时代“的写法
public static void main(String[] args) {
        // List applicationVOList = xxDao.queryXXXList(xxx) ; 业务处理
        List<ApplicationVO> applicationVOList = new ArrayList<>(); // 需要处理的集合
        // 我先造一些数据
        List<ApplicationVO> appVOList = Arrays.asList(
                new ApplicationVO("001", "name1"),
                new ApplicationVO("002", "name2"),
                new ApplicationVO("003", "name3")
        );
        Map<String, String> map = new HashMap<>();
        for (ApplicationVO vo : appVOList) {
            map.put(vo.getAppId(), vo.getName());
        }
        System.out.println(map);
        // ...
        // 业务处理逻辑

    }

这里是成功的拿到了Map集合。

在Java 8中，我们可以使用stream和Lambda表达式来实现这个需求。

Java8：List转Map

使用Collectors.toMap()进行List转Map，stream流操作之前要先给对象进行非空判断，因为Java8Stream对非空判断非常的不友好！

Collectors.toMap() 核心代码

appVOList.stream().collect(Collectors.toMap(ApplicationVO::getAppId, Function.identity(), (key1, key2) -> key2));

下面我给大家说说为什么要这么写！先从源码去理解，这样就能知道为什么要这么干！然后我再举例给大家加深印象。
先看看toMap的源码：
很明显，第一个参数是key值，第二个参数是value值，第三个参数是合并函数，它继承了另一个函数式接口
-> 这种箭头写法叫lambda表达式，不清楚的可以百度恶补一下。

 public static <T, K, U>
    Collector<T, ?, Map<K,U>> toMap(Function<? super T, ? extends K> keyMapper,// key值
                                    Function<? super T, ? extends U> valueMapper,// value值
                                    BinaryOperator<U> mergeFunction) {
        return toMap(keyMapper, valueMapper, mergeFunction, HashMap::new);
    }
    
// BinaryOperator源码 
public interface BinaryOperator<T> extends BiFunction<T,T,T> {
	public static <T> BinaryOperator<T> minBy(Comparator<? super T> comparator) {
        Objects.requireNonNull(comparator);
        return (a, b) -> comparator.compare(a, b) <= 0 ? a : b; // 返回两个元素中较小的一个
    }
    
	 public static <T> BinaryOperator<T> maxBy(Comparator<? super T> comparator) {
        Objects.requireNonNull(comparator);
        return (a, b) -> comparator.compare(a, b) >= 0 ? a : b;// 返回两个元素中较大的一个
    }
}

第一种：key为属性，value为对象

示范

  public static void main(String[] args) {
        // List applicationVOList = xxDao.queryXXXList(xxx) ; 业务处理
        List<ApplicationVO> applicationVOList = new ArrayList<>(); // 需要处理的集合
        // 我先造一些数据
        List<ApplicationVO> appVOList = Arrays.asList(
                new ApplicationVO("001", "name1"),
                new ApplicationVO("002", "name2"),
                new ApplicationVO("003", "name3")
        );
        // 对集合做非空判断，java8对空对象不友好
        Map<String, ApplicationVO> voMap
                = appVOList.stream().collect(Collectors.toMap(ApplicationVO::getAppId, Function.identity(), (key1, key2) -> key2));
        System.out.println(voMap);
        // ...
        // 业务处理逻辑

    }

上面这种写法，原本四行代码，现在只需要一行代码就能表达出来。（如果大家公司有代码量考核，我不建议大家跟我一样优雅起来 /手动滑稽）

Function.identity()

在转Map的时候的一种固定写法，当然也可以自己改造，源码是说输入什么输出什么，如果为了可读性，你也可以将这段代码写成 str ->str之类的写法，至于怎么写，也没有说哪种写法更好，但是我本人更倾向于function的这种写法。

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

(key1, key2) -> key2

可能大家已经看到我这个写法了，是不是看着就很高级，很优雅？这个其实是我自己在开发中遇到的一个坑，由于没有写这个，在key重复的时候，抛出了异常，很是恼火，于是当然也想第一次使用一样，不懂，于是点进源码瞅了瞅，然后查阅资料，于是乎就出现了上面我这种写法：(key1, key2) -> key2，它的意思是如果两个key重复了，让后面的key覆盖前面的key，完美解决bug，嘻嘻。
给大家演示一下key重复会抛出什么异常把：

public static void main(String[] args) {
        // List applicationVOList = xxDao.queryXXXList(xxx) ; 业务处理
        List<ApplicationVO> applicationVOList = new ArrayList<>(); // 需要处理的集合
        // 我先造一些数据
        List<ApplicationVO> appVOList = Arrays.asList(
                new ApplicationVO("001", "name1"),
                new ApplicationVO("002", "name2"),
                new ApplicationVO("003", "name3"),
                new ApplicationVO("003", "name3") // 这里出现了两个人一个姓名，那不得打起来0.0
        );
        // 对集合做非空判断，java8对空对象不友好
        Map<String, String> voMap = appVOList.stream().collect(Collectors.toMap(ApplicationVO::getAppId, vo -> vo.getName() + "你好帅"));
        System.out.println(voMap);
        // ...
        // 业务处理逻辑

    }

第二种：key为属性，value也为属性

示范

 public static void main(String[] args) {
        // List applicationVOList = xxDao.queryXXXList(xxx) ; 业务处理
        List<ApplicationVO> applicationVOList = new ArrayList<>(); // 需要处理的集合
        // 我先造一些数据
        List<ApplicationVO> appVOList = Arrays.asList(
                new ApplicationVO("001", "name1"),
                new ApplicationVO("002", "name2"),
                new ApplicationVO("003", "name3")
        );
        // 对集合做非空判断，java8对空对象不友好
        Map<String, String> voMap
                = appVOList.stream().collect(Collectors.toMap(ApplicationVO::getAppId, ApplicationVO::getName, (key1, key2) -> key2));
        System.out.println(voMap);
        // ...
        // 业务处理逻辑

    }

是不是很优雅，一行代码解决，key为appid，value是name字段，具体如何使用，根据业务需要来进行处理，如果只需要某个字段，建议这一种，毕竟像上面的第一种，直接返回整个对象的，更加的消耗内存。

第三种：对value值进行操作的

示范

public static void main(String[] args) {
        // List applicationVOList = xxDao.queryXXXList(xxx) ; 业务处理
        List<ApplicationVO> applicationVOList = new ArrayList<>(); // 需要处理的集合
        // 我先造一些数据
        List<ApplicationVO> appVOList = Arrays.asList(
                new ApplicationVO("001", "name1"),
                new ApplicationVO("002", "name2"),
                new ApplicationVO("003", "name3")
        );
        // 对集合做非空判断，java8对空对象不友好
        Map<String, String> voMap
                = appVOList.stream().collect(Collectors.toMap(ApplicationVO::getAppId, vo -> vo.getName() + "你好帅", (key1, key2) -> key2));
        System.out.println(voMap);
        // ...
        // 业务处理逻辑

    }

补充第四种：多个属性拼接成key，value为属性（或者对象）

 // 实例
public static void main(String[] args) {
        List<TopicVO> topicList = Arrays.asList(
                new TopicVO(1, 10, "主题1"),
                new TopicVO(2, 20, "主题2"),
                new TopicVO(3, 30, "主题3")
        );
        // 属性id和属性name组装成key，value值为age字段
        Map<String, Integer> topicMap
                = topicList.stream().collect(Collectors.toMap(vo -> vo.getId() + vo.getName(), TopicVO::getAge));
        
        System.out.println(topicMap);

    }

写在最后

本文从toMap底层介绍了一下Java8如何更加优雅的写出List转Map，避免大家跟我一样，在开发中被”叼“，希望大家学以致用，跟我一样，写优雅的代码。

Tips

上面基本上是我遇到的坑，希望遇到一次少一次，给大家留个问题，也是我思考过的：使用Java8一定优雅吗？效率一定高吗？什么时候for循环效率更高？欢迎大家给我留言，写这篇文章，可花了我不少时间和心思哦，喜欢的点个赞把。