关于Java8当中List转Map报错“Duplicate key”的原因以及解决办法

    其实Java8的lamdba表达式了解的不是很透彻，在工作中也只是使用最多的就是 for循环遍历、list转map、map转list、分组等功能。需要什么就从网上百度查找，然后按照样子在自己代码中修改下。其中的细节并没有留意过，就在今天我不小心就掉进了坑里。

    悲剧发生在今天早上，领导过来问我为什么业务上的数据有的时候会丢失，并让我排查下原因。我起初还怀疑是不是公司另外一端的接口有问题，于是就去问了下有没有上线之类的操作。得到的结果是：没有！

    那我就只能从自己的代码入手了，我开始本地启动连接访问线上的数据进行数据排查。运行了一遍之后发现没有什么问题，之后又连续点了几遍，结果报错了！！！

java.lang.IllegalStateException: Duplicate key com.houry.spring.bean.People@e2144e4
  at java.util.stream.Collectors.lambda$throwingMerger$0(Collectors.java:133)
  at java.util.HashMap.merge(HashMap.java:1253)
  at java.util.stream.Collectors.lambda$toMap$58(Collectors.java:1320)
  at java.util.stream.ReduceOps$3ReducingSink.accept(ReduceOps.java:169)
  at java.util.ArrayList$ArrayListSpliterator.forEachRemaining(ArrayList.java:1374)
  at java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:481)
  at java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:471)
  at java.util.stream.ReduceOps$ReduceOp.evaluateSequential(ReduceOps.java:708)
  at java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:234)
  at java.util.stream.ReferencePipeline.collect(ReferencePipeline.java:499)
  at com.houry.spring.bean.People.main(People.java:50)

    定位到报错的代码之后，我顿时懵逼了。这里怎么会报错呢？就是一个简单的List转Map啊！仔细看看提示信息“Duplicate key”就感受到了，那一定是重复的key引起的。代码类似下面这样的。（为了保密具体的业务代码我就不粘出来了图片）

public class People {

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public People(String name) {
        this.name = name;
    }

    public static void main(String[] args) {
        People p1 = new People("MonkeyBrother");
        People p2 = new People("MonkeyBrother");
        People p3 = new People("MonkeyBrother");
        People p4 = new People("MonkeyBrother");
        People p5 = new People("MonkeyBrother");
        List<People> list = new ArrayList<>();

        list.add(p1);
        list.add(p2);
        list.add(p3);
        list.add(p4);
        list.add(p5);
        
        Map<String, People> collect = list.stream().collect(Collectors.toMap(People::getName, p -> p));
        System.out.println(collect.toString());
    }

}

    我原本想的就是使用List转Map，然后相同的Key能够给我自动替换掉，但是按照我上面这样的写法它一定会报错。

list.stream().collect(Collectors.toMap(People::getName, p -> p));

    这样写是存在风险的，因为我生产业务代码中也是这样写的，所以我猜大概也是因为这样的原因报错了。为了死地更加明白些，我看了一下源码：

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);
}

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);
    }

private static <T> BinaryOperator<T> throwingMerger {
    return (u,v) -> { throw new IllegalStateException(String.format("Duplicate key %s", u)); };
}

    看到了“throwingMerger()”中的方法实现，我顿时无语了，我真的是太菜了！这个方法如果遇到相同的Key会直接抛出异常。然后转头看看这个方法的官方文档注释：

    原来是有方法可以替换的，需要我们再次传进一个对于重复key决策的表达式。就像官方给的文档那样：

    这里是合并map

    然后我把代码试着修改下结果就正常了：

public class People {

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public People(String name) {
        this.name = name;
    }

    public static void main(String[] args) {
        People p1 = new People("MonkeyBrother");
        People p2 = new People("MonkeyBrother");
        People p3 = new People("MonkeyBrother");
        People p4 = new People("MonkeyBrother");
        People p5 = new People("MonkeyBrother");
        List<People> list = new ArrayList<>();

        list.add(p1);
        list.add(p2);
        list.add(p3);
        list.add(p4);
        list.add(p5);

        Map<String, People> collect = list.stream().collect(Collectors.toMap(People::getName, p -> p, (k, v) -> k));

        System.out.println(collect.toString());

    }

}

    它和之前不同的原因在于，使用的是我们自己传入的表达式，而不是官方给的直接抛出异常。

    在我查阅资料的时候，发现了其实官方也为我们提供了一个其他的写法用来替换我们平时写的“p -> p”:

Map<String, People> collect = list.stream().collect(Collectors.toMap(People::getName, Function.identity(), (k, v) -> k));

    这个是我之前没有注意到的一点细节，我记得之前还有一些方法的实现也是直接抛出异常的，类似“ArrayList”中的“remove()”。