ストリームでCollections.toMap（）を使用するときに、リストの反復順序を維持するにはどうすればよいですか？

Question 1

私は次のようにMapからを作成してListいます：

List<String> strings = Arrays.asList("a", "bb", "ccc");

Map<String, Integer> map = strings.stream()
    .collect(Collectors.toMap(Function.identity(), String::length));

と同じ反復順序を維持したいと思いListます。メソッドLinkedHashMapを使用してを作成するにはどうすればよいCollectors.toMap()ですか？

Question 2

の2パラメータバージョンはCollectors.toMap()HashMap：を使用します

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

4パラメータバージョンを使用するには、次のものを置き換えることができます。

Collectors.toMap(Function.identity(), String::length)

と：

Collectors.toMap(
    Function.identity(), 
    String::length, 
    (u, v) -> {
        throw new IllegalStateException(String.format("Duplicate key %s", u));
    }, 
    LinkedHashMap::new
)

または、少しクリーンにするために、新しいtoLinkedMap()メソッドを作成して使用します。

public class MoreCollectors
{
    public static <T, K, U> Collector<T, ?, Map<K,U>> toLinkedMap(
        Function<? super T, ? extends K> keyMapper,
        Function<? super T, ? extends U> valueMapper)
    {
        return Collectors.toMap(
            keyMapper,
            valueMapper, 
            (u, v) -> {
                throw new IllegalStateException(String.format("Duplicate key %s", u));
            },
            LinkedHashMap::new
        );
    }
}

Question 3

あなた自身を提供しSupplier、AccumulatorそしてCombiner：

    List<String> myList = Arrays.asList("a", "bb", "ccc"); 
    // or since java 9 List.of("a", "bb", "ccc");
    
    LinkedHashMap<String, Integer> mapInOrder = myList
        .stream()
        .collect(
            LinkedHashMap::new,                                   // Supplier
            (map, item) -> map.put(item, item.length()),          // Accumulator
            Map::putAll);                                         // Combiner

    System.out.println(mapInOrder);  // {a=1, bb=2, ccc=3}

Question 4

Kotlinでは、toMap()順序を維持しています。

fun <K, V> Iterable<Pair<K, V>>.toMap(): Map<K, V>
指定されたペアのコレクションからのすべてのキーと値のペアを含む新しいマップを返します。

返されたマップは、元のコレクションのエントリの反復順序を保持します。2つのペアのいずれかが同じキーを持っている場合、最後のペアがマップに追加されます。

その実装は次のとおりです。

public fun <K, V> Iterable<Pair<K, V>>.toMap(): Map<K, V> {
    if (this is Collection) {
        return when (size) {
            0 -> emptyMap()
            1 -> mapOf(if (this is List) this[0] else iterator().next())
            else -> toMap(LinkedHashMap<K, V>(mapCapacity(size)))
        }
    }
    return toMap(LinkedHashMap<K, V>()).optimizeReadOnlyMap()
}

使用法は単純です：

val strings = listOf("a", "bb", "ccc")
val map = strings.map { it to it.length }.toMap()

の基になるコレクションmapはLinkedHashMap（挿入順）です。

Question 5

いくつかのフィールドによってオブジェクトの配列をマップする単純な関数：

public static <T, E> Map<E, T> toLinkedHashMap(List<T> list, Function<T, E> someFunction) {
    return list.stream()
               .collect(Collectors.toMap(
                   someFunction, 
                   myObject -> myObject, 
                   (key1, key2) -> key1, 
                   LinkedHashMap::new)
               );
}


Map<String, MyObject> myObjectsByIdMap1 = toLinkedHashMap(
                listOfMyObjects, 
                MyObject::getSomeStringField()
);

Map<Integer, MyObject> myObjectsByIdMap2 = toLinkedHashMap(
                listOfMyObjects, 
                MyObject::getSomeIntegerField()
);