Kotlin में HashMap पर पुनरावृति कैसे करें?

परिचय

HashMap कुंजी-मान जोड़े संग्रहीत करता है जहां कुंजी अद्वितीय होती है। Kotlin HashMap पर पुनरावृति के कई तरीके प्रदान करता है।

HashMap कंस्ट्रक्टर्स

• `HashMap()` - खाली मैप
• `HashMap(initialCapacity: Int, loadFactor: Float = 0f)`
• `HashMap(initialCapacity: Int)`
• `HashMap(original: Map<out K, V>)` - मौजूदा मैप से कॉपी

HashMap बनाना और भरना

fun main() {
    val subjectMap = HashMap().apply {
        put("Java", 1)
        put("Kotlin", 2)
        put("Python", 3)
        put("C++", 4)
        put("SQL", 5)
    }
    
    // या मैप लिटरल सिंटैक्स (Kotlin 1.1+)
    val subjectMap2 = mapOf(
        "Java" to 1,
        "Kotlin" to 2,
        "Python" to 3,
        "C++" to 4,
        "SQL" to 5
    ).toMutableMap()
}

विधि 1: for लूप (डीस्ट्रक्चरिंग के साथ)

fun main() {
    val subject = hashMapOf(
        "Java" to 1, "Kotlin" to 2, "Python" to 3, "C++" to 4, "SQL" to 5
    )
    
    println("--- for लूप के साथ पुनरावृति ---")
    for ((key, value) in subject) {
        println("विषय: $key, प्राथमिकता: $value")
    }
}

आउटपुट

--- for लूप के साथ पुनरावृति ---
विषय: Java, प्राथमिकता: 1
विषय: C++, प्राथमिकता: 4
विषय: Kotlin, प्राथमिकता: 2
विषय: Python, प्राथमिकता: 3
विषय: SQL, प्राथमिकता: 5

विधि 2: forEach() मेथड

fun main() {
    val subject = hashMapOf("Java" to 1, "Kotlin" to 2, "Python" to 3)
    
    println("--- forEach के साथ पुनरावृति ---")
    subject.forEach { (key, value) ->
        println("विषय: $key, प्राथमिकता: $value")
    }
    
    // या एंट्री के रूप में
    subject.forEach { entry ->
        println("${entry.key} -> ${entry.value}")
    }
}

विधि 3: iterator() मेथड (मेमोरी कुशल)

fun main() {
    val subject = hashMapOf("Java" to 1, "Kotlin" to 2, "Python" to 3)
    
    println("--- iterator() के साथ पुनरावृति ---")
    val iterator = subject.entries.iterator()
    while (iterator.hasNext()) {
        val entry = iterator.next()
        println("विषय: ${entry.key}, प्राथमिकता: ${entry.value}")
        
        // पुनरावृति के दौरान सुरक्षित हटाने
        if (entry.key == "Kotlin") {
            iterator.remove()
        }
    }
}

विधि 4: Keys/Values पर पुनरावृति

fun main() {
    val subject = hashMapOf("Java" to 1, "Kotlin" to 2)
    
    // केवल कुंजियाँ
    println("--- कुंजियाँ ---")
    subject.keys.forEach { println(it) }
    
    // केवल मान
    println("--- मान ---")
    subject.values.forEach { println(it) }
    
    // कुंजियों के लिए iterator
    val keyIterator = subject.keys.iterator()
    while (keyIterator.hasNext()) {
        val key = keyIterator.next()
        println("$key -> ${subject[key]}")
    }
}

विधि 5: फंक्शनल रूपांतरण (Map पर पुनरावृति नहीं, लेकिन उपयोगी)

fun main() {
    val subject = hashMapOf("Java" to 1, "Kotlin" to 2, "Python" to 3)
    
    // फ़िल्टर
    val highPriority = subject.filter { (_, v) -> v > 1 }
    println("उच्च प्राथमिकता: $highPriority")
    
    // मैप मान
    val doubled = subject.mapValues { (_, v) -> v * 2 }
    println("डबल्ड: $doubled")
    
    // मैप कुंजी
    val upperKeys = subject.mapKeys { (k, _) -> k.uppercase() }
    println("अपरकेस कुंजियाँ: $upperKeys")
}

प्रदर्शन नोट्स

• for लूप / forEach: सबसे पठनीय, सामान्य उपयोग के लिए ठीक
• iterator(): पुनरावृति के दौरान हटाने के लिए आवश्यक
• entries.iterator(): कुंजी+मान दोनों के लिए कुशल
• बड़े मैप्स के लिए, `forEach` थोड़ा तेज हो सकता है

सारांश