Java8 Lambda表达式 List转Map

背景

最近项目中，因为业务需要，我使用了for循环进行List转Map，但是使用传统的for循环可以实现功能，但是一点不优雅。作为一名程序员，不能仅限于实现功能，只有不断的去优化代码，才能提升自己的编码能力，于是我就想到了Java8的新特性，使用stream流进行操作，让代码一下子优雅起来了，给你们看看我是如何一步步将代码优雅起来的，顺便学习了一波 Collectors.toMap() 的源码。

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

让我们先来看一个简单的例子，假设我们需要给前端返回一个MessageTypeDTO类，该类具有id、type和titleName属性

// 需要操作的对象

@Data
public class MessageTypeDTO {

    // id（唯一）
    private Integer id;
    //消息类型
    private String type;
    // 标题名称
    private String titleName;

    // 业务字段 ...

    public MessageTypeDTO() {}

    public MessageTypeDTO(Integer id, String type,String titleName) {
        this.id = id;
        this.type = type;
        this.titleName = titleName;
    }
}

// 业务层代码
// 先看看传统for循环的写法
public static void main(String[] args) {
        
        List<MessageTypeDTO> messageTypeList = new ArrayList<>(); 
        // 需要处理的集合
        // 我先造一些数据
        List<MessageTypeDTO> msgTypeList = Arrays.asList(
                new MessageTypeDTO(1,"99","全部"),
                new MessageTypeDTO(2,"1","普通"),
                new MessageTypeDTO(3,"2","紧急")
        );
        Map<String, String> map = new HashMap<>();
        for (MessageTypeDTO msgDTO : msgTypeList) {
            map.put(msgDTO.getId(), vo.getTitleName());
        }
        System.out.println(map);
        // ...
        // 业务处理逻辑

    }

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

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

Collectors.toMap() 核心代码

messageTypeList.stream().collect(Collectors.toMap(MessageTypeDTO::getId, 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<MessageTypeDTO> messageTypeList = new ArrayList<>(); 
       
        // 造一些数据
        List<MessageTypeDTO> msgTypeList = Arrays.asList(
                new MessageTypeDTO(1,"99","全部"),
                new MessageTypeDTO(2,"1","普通"),
                new MessageTypeDTO(3,"2","紧急")
        );
    
        // 对集合做非空判断，java8对空对象不友好
        Map<String, MessageTypeDTO> msgMap
                = msgTypeList.stream().collect(Collectors.toMap(MessageTypeDTO::getId, Function.identity(), (key1, key2) -> key2));
        System.out.println(msgMap);
        // ...
        // 业务处理逻辑

    }

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

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<MessageTypeDTO> messageTypeDTOList = new ArrayList<>(); // 需要处理的集合
        // 我先造一些数据
        List<MessageTypeDTO> msgDTOList = Arrays.asList(
                new MessageTypeDTO(1, "99","全部"),
                new MessageTypeDTO(2, "1","普通"),
                new MessageTypeDTO(3, "2","紧急"),
                new MessageTypeDTO(4, "2","紧急") // 这里出现了两个类型，类型都一样，那不就打架了么
        );
        // 对集合做非空判断，java8对空对象不友好
        Map<String, String> dtoMap = msgDTOList.stream().collect(Collectors.toMap(MessageTypeDTO::getId, msg -> msg.getgetTitleName() + "测试"));
        System.out.println(dtoMap);
        // ...
        // 业务处理逻辑

    }

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

List<MessageTypeDTO> messageTypeDTOList = new ArrayList<>(); // 需要处理的集合
        // 我先造一些数据
        List<MessageTypeDTO> msgDTOList = Arrays.asList(
                new MessageTypeDTO(1, "99","全部"),
                new MessageTypeDTO(2, "1","普通"),
                new MessageTypeDTO(3, "2","紧急"),
                 new MessageTypeDTO(4, "2","紧急")
                // 这里出现了两个类型，title名称都一样，如果返回给前端那不尴尬了
        );
        // 对集合做非空判断，java8对空对象不友好
        Map<String, String> dtoMap = msgDTOList.stream()
                .collect(Collectors.toMap(MessageTypeDTO::getType, MessageTypeDTO::getTitleName,(key1,key2)->key2));
        System.out.println(dtoMap);

是不是很优雅，一行代码解决，key为type，value是titleName字段，具体如何使用，根据业务需要来进行处理，如果只需要某个字段，建议这一种，毕竟像上面的第一种，直接返回整个对象的，更加的消耗内存。
写在最后
本文从toMap底层介绍了一下Java8如何更加优雅的写出List转Map，避免大家跟我一样，在开发中被”叼“，希望大家学以致用，跟我一样，写优雅的代码。

小Tips
基本上是我遇到的坑，希望遇到一次少一次，给大家留个问题，也是我思考过的：使用Java8一定优雅吗？效率一定高吗？什么时候for循环效率更高？欢迎大家给我留言可以一起讨论哦。写文章不易，可能不是很高的质量，但是个人觉得可以帮忙大家避一些坑了，帮忙点点赞哦。