Java 8 Collectors.toMap SortedMap

Ich verwende Java 8-Lambdas und möchte verwenden Collectors toMap zurückgeben a SortedMap. Das Beste, was mir einfällt, ist, Folgendes anzurufen Collectors toMap Methode mit einem Dummy mergeFunction und mapSupplier gleicht TreeMap::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);
}

Ich möchte jedoch keine Zusammenführungsfunktion übergeben, da ich nur möchte throwingMerger()auf die gleiche Weise wie die Basis toMapUmsetzung wie folgt:

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

Was wäre die Best-Practice-Methode zur Verwendung Collectors zurückgeben a SortedMap?

Ich denke viel besser geht es nicht:

.collect(Collectors.toMap(keyMapper, valueMapper,
                        (v1,v2) ->{ throw new RuntimeException(String.format("Duplicate key for values %s and %s", v1, v2));},
                        TreeMap::new));

bei dem die throw Lambda ist das gleiche wie throwingMerger() aber ich kann das nicht direkt aufrufen, da es sich um ein privates Paket handelt (Sie können natürlich immer Ihre eigene statische Methode dafür erstellen, wie z throwingMerger() ist. )

Basierend auf der Bestätigung von dkatzel, dass es keine nette API-Methode gibt, habe ich mich dafür entschieden, meine eigene benutzerdefinierte Collectors-Klasse beizubehalten:

public final class StackOverflowExampleCollectors {

    private StackOverflowExampleCollectors() {
        throw new UnsupportedOperationException();
    }

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

    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, Supplier<M> mapSupplier) {
        return Collectors.toMap(keyMapper, valueMapper, throwingMerger(), mapSupplier);
    }

}

Scheint, dass es keinen Standardweg gibt, dies zu tun, ohne einen eigenen zu definieren throwingMerger() -Methode oder mit explizitem Lambda. In meiner StreamEx-Bibliothek habe ich die toSortedMap Methode, die auch Verwendet mein eigenes throwingMerger().

Sie können dies auch tun, indem Sie Collectors.toMap() erlauben, die zurückzugebende Karte zurückzugeben, und diese dann an eine neue TreeMap<>() übergeben.

Der Vorbehalt dabei ist, dass dies nur funktioniert, wenn Ihr “hashCode()+equals()” und “compareTo” konsistent sind. Wenn sie nicht konsistent sind, wird die HashMap am Ende andere Schlüsselsätze entfernen als Ihre TreeMap.

Wenn Sie die Guave-Bibliothek verwenden, können Sie Folgendes verwenden:

.collect(ImmutableSortedMap.toImmutableSortedMap(comparator, keyMapper, valueMapper));

Die resultierende Karte ist a SortedMap und auch unveränderlich.