스트림에서 Collections.toMap ()을 사용할 때 목록의 반복 순서를 어떻게 유지합니까? strings = Arrays.asList(“a”, “bb”, “ccc”); Map<String,

다음과 같이 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()있습니까?

답변

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

답변

자신의 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}

답변

Kotlin에서는 toMap()주문이 보존됩니다.

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

주어진 쌍 모음에서 모든 키-값 쌍을 포함하는 새 맵을 반환합니다.

반환 된 맵은 원래 컬렉션의 항목 반복 순서를 유지합니다. 두 쌍 중 하나가 동일한 키를 갖는 경우 마지막 하나가 맵에 추가됩니다.

구현은 다음과 같습니다.

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(삽입 순서)입니다.

답변

일부 필드로 객체 배열을 매핑하는 간단한 함수 :

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

답변