¿Cómo mantengo el orden de iteración de una lista cuando uso Collections.toMap () en una secuencia?

Estoy creando una Mapde la Listsiguiente manera:

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

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

Quiero mantener el mismo orden de iteración que en el List. ¿Cómo puedo crear un LinkedHashMapusando los Collectors.toMap()métodos?

La versión de 2 parámetros deCollectors.toMap() utiliza un 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);
}

Para usar la versión de 4 parámetros , puede reemplazar:

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

con:

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

O para hacerlo un poco más limpio, escriba un nuevo toLinkedMap()método y utilícelo:

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

Proporcionar su propia Supplier, Accumulatory 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}

En Kotlin, toMap()se preserva el orden.

fun <K, V> Iterable<Pair<K, V>>.toMap(): Map<K, V>

Devuelve un nuevo mapa que contiene todos los pares clave-valor de la colección de pares dada.

El mapa devuelto conserva el orden de iteración de entrada de la colección original. Si cualquiera de los dos pares tuviera la misma clave, el último se agrega al mapa.

Aquí está su implementación:

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

El uso es simplemente:

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

La colección subyacente de mapes a LinkedHashMap(que está ordenada por inserción).

Función simple para mapear una matriz de objetos por algún campo:

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