किसी स्ट्रीम पर 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

कोटलिन में, 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(जो प्रविष्टि-आदेश दिया गया है) है।

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