【Java】Exception in thread "main" java.lang.IllegalStateException: Duplicate key

最新推荐文章于 2024-08-12 08:09:24 发布

绝世好阿狸

最新推荐文章于 2024-08-12 08:09:24 发布

阅读量1w

点赞数 1

分类专栏： java 文章标签： toMap

本文链接：https://blog.csdn.net/u010900754/article/details/84852494

版权

java 专栏收录该内容

202 篇文章 6 订阅

订阅专栏

java8 stream 的toMap方法，如果key有重复的就会跑出上面的异常，比如：

        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(1);
        System.out.println(list.stream().collect(Collectors.toMap(e->e, e->"hello")));

Exception in thread "main" java.lang.IllegalStateException: Duplicate key 1
   at java.util.stream.Collectors.lambda$throwingMerger$0(Collectors.java:133)
   at java.util.HashMap.merge(HashMap.java:1254)
   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:1382)
   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.liyao.AAA.main(AAA.java:32)

解决办法是：使用重载方法，多传入一个merge function来处理冲突

        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(1);
//        System.out.println(list.stream().collect(Collectors.toMap(e->e, e->"hello")));
        System.out.println(list.stream().collect(Collectors.toMap(e->e, e->"1", (k,v)->k + "world")));

 /**
     * Returns a {@code Collector} that accumulates elements into a
     * {@code Map} whose keys and values are the result of applying the provided
     * mapping functions to the input elements.
     *
     * <p>If the mapped
     * keys contains duplicates (according to {@link Object#equals(Object)}),
     * the value mapping function is applied to each equal element, and the
     * results are merged using the provided merging function.
     *
     * @apiNote
     * There are multiple ways to deal with collisions between multiple elements
     * mapping to the same key.  The other forms of {@code toMap} simply use
     * a merge function that throws unconditionally, but you can easily write
     * more flexible merge policies.  For example, if you have a stream
     * of {@code Person}, and you want to produce a "phone book" mapping name to
     * address, but it is possible that two persons have the same name, you can
     * do as follows to gracefully deals with these collisions, and produce a
     * {@code Map} mapping names to a concatenated list of addresses:
     * <pre>{@code
     *     Map<String, String> phoneBook
     *         people.stream().collect(toMap(Person::getName,
     *                                       Person::getAddress,
     *                                       (s, a) -> s + ", " + a));
     * }</pre>
     *
     * @implNote
     * The returned {@code Collector} is not concurrent.  For parallel stream
     * pipelines, the {@code combiner} function operates by merging the keys
     * from one map into another, which can be an expensive operation.  If it is
     * not required that results are merged into the {@code Map} in encounter
     * order, using {@link #toConcurrentMap(Function, Function, BinaryOperator)}
     * may offer better parallel performance.
     *
     * @param <T> the type of the input elements
     * @param <K> the output type of the key mapping function
     * @param <U> the output type of the value mapping function
     * @param keyMapper a mapping function to produce keys
     * @param valueMapper a mapping function to produce values
     * @param mergeFunction a merge function, used to resolve collisions between
     *                      values associated with the same key, as supplied
     *                      to {@link Map#merge(Object, Object, BiFunction)}
     * @return a {@code Collector} which collects elements into a {@code Map}
     * whose keys are the result of applying a key mapping function to the input
     * elements, and whose values are the result of applying a value mapping
     * function to all input elements equal to the key and combining them
     * using the merge function
     *
     * @see #toMap(Function, Function)
     * @see #toMap(Function, Function, BinaryOperator, Supplier)
     * @see #toConcurrentMap(Function, Function, BinaryOperator)
     */
    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);
    }