Làm cách nào để giữ thứ tự lặp lại của Danh sách khi sử dụng Collections.toMap () trên luồng?

Tôi đang tạo một Maptừ một Listnhư sau:

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

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

Tôi muốn giữ cùng một thứ tự lặp lại như trong List. Làm cách nào tôi có thể tạo một LinkedHashMapbằng các Collectors.toMap()phương pháp?

Các phiên bản 2 tham số củaCollectors.toMap() sử dụng 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);
}

Để sử dụng phiên bản 4 tham số , bạn có thể thay thế:

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

với:

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

Hoặc để làm cho nó gọn gàng hơn một chút, hãy viết một toLinkedMap()phương thức mới và sử dụng:

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

Cung cấp của riêng bạn Supplier, Accumulatorvà 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}

Trong Kotlin, toMap()là bảo tồn trật tự.

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

Trả về một bản đồ mới chứa tất cả các cặp khóa-giá trị từ tập hợp các cặp đã cho.

Bản đồ được trả về bảo toàn thứ tự lặp lại mục nhập của tập hợp ban đầu. Nếu bất kỳ cặp nào trong hai cặp có cùng khóa, cặp cuối cùng sẽ được thêm vào bản đồ.

Đây là cách triển khai của 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()
}

Cách sử dụng chỉ đơn giản là:

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

Tập hợp cơ bản cho maplà a LinkedHashMap(được sắp xếp theo thứ tự chèn).

Chức năng đơn giản để ánh xạ mảng đối tượng theo một số trường:

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