Kotlin MutableMap ist eine Schnittstelle von Sammlungsframeworks, die Objekte in Form von Schlüsseln und Werten enthält. Es ermöglicht dem Benutzer, die jedem Schlüssel entsprechenden Werte effizient abzurufen. Der Schlüssel und die Werte können aus verschiedenen Paaren wie <Int, String>, <Char, String> usw. bestehen.
Um die MutableMap-Schnittstelle zu verwenden, müssen wir Funktionen wie unten gezeigt verwenden 
 

mutableMapOf() or mutableMapOf <K, V>()

Zum Deklarieren der MutableMap-Schnittstelle
 

interface MutableMap<K, V> : Map<K, V> (source)

Beispiel einer änderbaren Funktion mit Einträgen, Schlüsseln und Werten.

fun main(args: Array<String>) {
    val items = mutableMapOf("Box" to 12, "Books" to 18, "Table" to 13)
 
    println("Entries: " + items.entries)       //Printing Entries
    println("Keys:" + items.keys)              //Printing Keys
    println("Values:" + items.values)          //Printing Values
}

Ausgabe: 
 

Entries: [Box=12, Books=18, Table=13]
Keys:[Box, Books, Table]
Values:[12, 18, 13]

Kartengröße finden –

Wir können die Größe der veränderlichen Karte mit zwei Methoden bestimmen. Durch Verwendung der size-Eigenschaft der Karte und durch Verwendung der count()-Methode. 
 

fun main(args : Array<String>) {
 
    val ranks = mutableMapOf(1 to "India",2 to "Australia",
        3 to "England",4 to "Africa")
    //method 1
    println("The size of the mutablemap is: "+ranks.size)
    //method 2
    println("The size of the mutablemap is: "+ranks.count())
}

Ausgabe: 
 

The size of the mutablemap is: 4
The size of the mutablemap is: 4

Holen Sie sich Werte von Map –

Wir können Werte aus einer veränderlichen Karte abrufen, indem wir verschiedene Methoden verwenden, die im folgenden Programm beschrieben werden. 
 

fun main() {
 
    val ranks = mutableMapOf(1 to "India",2 to "Australia",
        3 to "England",4 to "Africa")
 
    //method 1
    println("Team having rank #1 is: "+ranks[1])
    //method 2
    println("Team having rank #3 is: "+ranks.getValue(3))
    //method 3
    println("Team having rank #4 is: "+ranks.getOrDefault(4, 0))
    // method  4
    val team = ranks.getOrElse(2 ,{ 0 })
    println(team)
}

Ausgabe: 
 

Team having rank #1 is: India
Team having rank #3 is: England
Team having rank #4 is: Africa
Australia

put() und putAll() Funktion

Die Funktionen put() und putAll() werden verwendet, um Elemente in der MutableMap hinzuzufügen. Die Funktion put() fügt einzelne Elemente gleichzeitig hinzu, während die Funktion putAll() verwendet werden kann, um mehrere Elemente gleichzeitig in MutableMap hinzuzufügen.
Kotlin-Programm zur Verwendung der Funktionen put() und putAll() – 
 

fun main(args: Array<String>) {
    val mutableMap = mutableMapOf<String, String>()
    mutableMap.put("Name", "Geek")
    mutableMap.put("Country", "India")
 
    val map = mapOf<String,String>("Department" to "Computer Science",
        "Hobby" to "Coding")
 
    println("<----Traverse mutableMap---->")
    for (key in mutableMap.keys) {
        println("Key = "+key +", "+"Value = "+mutableMap[key])
    }
    mutableMap.putAll(map)
    println("<----Traversal after putting hashmap---->")
    for (key in mutableMap.keys) {
        println("Key = "+key +", "+"Value = "+mutableMap[key])
    }
}

Ausgabe: 
 

<----Traverse mutableMap---->
Key = Name, Value = Geek
Key = Country, Value = India
<----Traversal after putting hashmap---->
Key = Name, Value = Geek
Key = Country, Value = India
Key = Department, Value = Computer Science
Key = Hobby, Value = Coding

Funktion remove(key) und remove(key, value) –

Die Funktion remove(key) wird verwendet, um den Wert zu entfernen, der dem erwähnten Schlüssel entspricht. 
Die Funktion remove(key, value) wird verwendet, um Elemente zu entfernen, die Schlüssel und Werte enthalten
. Kotlin-Programm zur Demonstration der Funktion remove() – 
 

fun main(args: Array<String>) {
 
    val mutableMap = mutableMapOf<String, String>()
    mutableMap.put("Name", "Geek")
    mutableMap.put("Company", "GeeksforGeeks")
    mutableMap.put("Country", "India")
 
    for (key in mutableMap.keys) {
        println("Key = ${key}, Value = ${mutableMap[key]}")
    }
    println()
    println("Remove the Key: "+mutableMap.remove("Country"))
    println()
    println("Is pair removes from the map: "
            +mutableMap.remove("Company","GeeksforGeeks"))
    println()
    println("<---Traverse Again--->")
    for (key in mutableMap.keys) {
        println("Key = ${key}, Value = ${mutableMap[key]}")
    }
}

Ausgabe: 
 

Key = Name, Value = Geek
Key = Company, Value = GeeksforGeeks
Key = Country, Value = India

Remove the Key: India

Is pair removes from the map: true

<---Traverse Again--->
Key = Name, Value = Geek

clear()-Funktion –

Wird verwendet, um alle Elemente aus der mutableMap zu entfernen.
Kotlin-Programm zur Verwendung der Funktion clear() – 
 

fun main(args: Array<String>) {
 
    val mutableMap: MutableMap<String, String> = mutableMapOf<String, String>()
    mutableMap.put("Name", "Geek")
    mutableMap.put("Company", "GeeksforGeeks")
 
    for (key in mutableMap.keys) {
        println("Key = ${key}, Value = ${mutableMap[key]}")
    }
 
    println("mutableMap.clear()")
    println("Method called to clear the map: "+mutableMap.clear())
    println("Map Empty: "+mutableMap)
}

Ausgabe: 
 

Key = Name, Value = Geek
Key = Company, Value = GeeksforGeeks
mutableMap.clear()
Method called to clear the map: kotlin.Unit
Map Empty: {}

Traversieren in einer veränderlichen Karte –

Traversieren bedeutet, jeden Node in den Datenstrukturen wie verknüpfte Liste, Arrays, Bäume usw. zu durchlaufen. 
Es bedeutet nur, dass mindestens einmal zu jedem Node gereist wird, um ihn dem Benutzer anzuzeigen oder eine Operation darauf auszuführen. 
Um dies zu verstehen, nehmen wir ein Beispiel unter 
dem Kotlin-Programm, um die Traversierung zu demonstrieren – 
 

fun main(args: Array<String>) {     //Declaring function
    //Creating MutableMap of different types
    val mutableMap = mutableMapOf(1 to "Aditya",
        4 to "Vilas", 2 to "Manish", 3 to "Manjot")
 
    for (key in mutableMap.keys) {
        println("Key = ${key}, Value = ${mutableMap[key]}")     
    }
}

Ausgabe: 
 

Key = 1, Value = Aditya
Key = 4, Value = Vilas
Key = 2, Value = Manish
Key = 3, Value = Manjot