Kotlin List को Map में बदलना: रूपांतरण और कोड त्वरण के लिए गाइड

सूची से मैप तक: यह क्यों महत्वपूर्ण है और इसे सही तरीके से कैसे करें?

एक स्थिति की कल्पना करें: आप Kotlin में एक एप्लिकेशन पर काम कर रहे हैं, API से उपयोगकर्ताओं की एक सूची प्राप्त हुई है। आपको किसी उपयोगकर्ता को उसके ID द्वारा जल्दी से ढूंढना है। हर बार सूची को पुनरावृत्त करना — O(n) है, जो 1000+ तत्वों पर दर्द बन जाता है। जबकि Map द्वारा खोज — O(1) है। अंतर बहुत बड़ा है।

प्रश्न "How to convert List to Map in Kotlin?" — Stack Overflow पर सबसे लोकप्रिय प्रश्नों में से एक है। और यह व्यर्थ नहीं है: गलत रूपांतरण डेटा हानि, प्रदर्शन में गिरावट या अजीब बग का कारण बन सकता है। आज हम सरल से लेकर उन्नत तक, परिवर्तन के 5 तरीकों पर चर्चा करेंगे, और जानेंगे कि अपने कोड को 10 गुना कैसे तेज करें।

मूल दृष्टिकोण: associate, toMap और groupBy

1. क्लासिक: associate — सबसे आम विकल्प

फ़ंक्शन associate रूपांतरण का राजा है। यह एक लैम्ब्डा लेता है जो एक जोड़ी (कुंजी, मान) लौटाता है।

data class User(val id: Int, val name: String, val age: Int)\n\nval users = listOf(\n    User(1, "अन्ना", 25),\n    User(2, "बोरिस", 30),\n    User(3, "विक्टर", 22)\n)\n\n// सबसे सरल मामला: id -> name\nval idToNameMap: Map<Int, String> = users.associate { it.id to it.name }\nprintln(idToNameMap) // {1=अन्ना, 2=बोरिस, 3=विक्टर}\n\n// id द्वारा पूर्ण ऑब्जेक्ट\nval userMap: Map<Int, User> = users.associate { it.id to it }\nprintln(userMap[2]) // User(id=2, name="बोरिस", age=30)\n

महत्वपूर्ण: यदि सूची में डुप्लिकेट कुंजियाँ हैं (associate अंतिम से ओवरराइट करेगा), तो आपको इसका पता भी नहीं चलेगा। सावधान रहें!

2. toMap — जब आपके पास पहले से जोड़ियों का संग्रह हो

यदि आपने पहले से Pair<K, V> की एक सूची बनाई है, तो toMap() का उपयोग करें।

val pairs = listOf(\n    1 to "अन्ना",\n    2 to "बोरिस",\n    3 to "विक्टर"\n)\n\nval mapFromPairs: Map<Int, String> = pairs.toMap()\nprintln(mapFromPairs) // {1=अन्ना, 2=बोरिस, 3=विक्टर}\n

toMap Map.Entry संग्रह और अन्य जोड़ी पुनरावर्तकों के साथ भी काम करता है।

3. groupBy — जब एक कुंजी के लिए कई मान हों

कभी-कभी तत्वों को कुंजी द्वारा समूहित करने की आवश्यकता होती है। उदाहरण के लिए, उपयोगकर्ताओं को उम्र के अनुसार समूहित करना।

val usersByAge: Map<Int, List<User>> = users.groupBy { it.age }\n// परिणाम: {25=[User(id=1, name=अन्ना, age=25)], 30=[User(id=2, name=बोरिस, age=30)], 22=[User(id=3, name=विक्टर, age=22)]}\n

groupBy Map<K, List<V>> लौटाता है। विश्लेषण, फ़िल्टरिंग और रिपोर्ट निर्माण के लिए आदर्श।

उन्नत तकनीकें: जब मानक विधियाँ पर्याप्त न हों

4. associateBy — यदि आपको केवल कुंजी चाहिए, और मान स्वयं तत्व है

फ़ंक्शन associateBy associate { key to it } का पर्याय है, लेकिन पढ़ने में बेहतर है।

val userMapById: Map<Int, User> = users.associateBy { it.id }\n// समतुल्य: users.associate { it.id to it }\nprintln(userMapById[1]) // User(id=1, name=अन्ना, age=25)\n

सुझाव: जब आपको "कुंजी → स्वयं ऑब्जेक्ट" शब्दकोश बनाने की आवश्यकता हो, तो associateBy का उपयोग करें। कोड साफ हो जाता है।

5. डुप्लिकेट प्रबंधन के साथ कस्टम रूपांतरण

मान लीजिए, आपके पास ऑर्डर की एक सूची है, और कई ऑर्डर का एक ही ID हो सकता है (उदाहरण के लिए, विभिन्न संस्करण)। मानक associate बस ओवरराइट करेगा। क्या होगा यदि आप सभी को संरक्षित करना चाहते हैं?

data class Order(val id: Int, val amount: Double, val version: Int)\n\nval orders = listOf(\n    Order(1, 100.0, 1),\n    Order(1, 150.0, 2), // डुप्लिकेट id, लेकिन अलग संस्करण\n    Order(2, 200.0, 1)\n)\n\n// विकल्प 1: id द्वारा समूहीकरण\nval ordersGrouped: Map<Int, List<Order>> = orders.groupBy { it.id }\n// {1=[Order(1, 100.0, 1), Order(1, 150.0, 2)], 2=[O