Karten

Eine Map verbindet keys mit values und sucht einen Wert anhand eines Schlüssels.

Sie erstellen eine Map, indem Sie mapOf() Schlüssel-Wert-Paare bereitstellen. Mit to trennen wir jeden Schlüssel von seinem zugehörigen Wert:

// Maps/Maps.kt
import atomictest.eq

fun main() {
  val constants = mapOf(
    "Pi" to 3.141,
    "e" to 2.718,
    "phi" to 1.618
  )
  constants eq
    "{Pi=3.141, e=2.718, phi=1.618}"

  // Look up a value from a key:
  constants["e"] eq 2.718              // [1]
  constants.keys eq setOf("Pi", "e", "phi")
  constants.values eq "[3.141, 2.718, 1.618]"

  var s = ""
  // Iterate through key-value pairs:
  for (entry in constants) {           // [2]
    s += "${entry.key}=${entry.value}, "
  }
  s eq "Pi=3.141, e=2.718, phi=1.618,"

  s = ""
  // Unpack during iteration:
  for ((key, value) in constants)      // [3]
    s += "$key=$value, "
  s eq "Pi=3.141, e=2.718, phi=1.618,"
}

• [1] Der [] Operator sucht einen Wert mithilfe eines Schlüssels. Sie können alle Schlüssel mit keys und alle Werte mit values erzeugen. Der Aufruf von keys erzeugt eine Set, da alle Schlüssel in einem Map einzigartig sein müssen, andernfalls gäbe es eine Mehrdeutigkeit bei einer Suche.
• [2] Das Iterieren durch ein Map erzeugt Schlüssel-Wert-Paare als Mapeinträge.
• [3] Sie können Schlüssel und Werte beim Iterieren entpacken.

Ein einfaches Map ist schreibgeschützt. Hier ist ein MutableMap:

// Maps/MutableMaps.kt
import atomictest.eq

fun main() {
  val m =
    mutableMapOf(5 to "five", 6 to "six")
  m[5] eq "five"
  m[5] = "5ive"
  m[5] eq "5ive"
  m += 4 to "four"
  m eq mapOf(5 to "5ive",
    4 to "four", 6 to "six")
}

map[key] = value fügt den Wert hinzu oder ändert ihn, der mit dem Schlüssel verknüpft ist. Sie können auch explizit ein Paar hinzufügen, indem Sie map += key to value verwenden.

mapOf() und mutableMapOf() bewahren die Reihenfolge, in der die Elemente in die Map eingefügt werden. Dies ist nicht für andere Typen von Map garantiert.

Eine schreibgeschützte Map erlaubt keine Änderungen:

// Maps/ReadOnlyMaps.kt
import atomictest.eq

fun main() {
  val m = mapOf(5 to "five", 6 to "six")
  m[5] eq "five"
  // m[5] = "5ive" // Fails
  // m += (4 to "four") // Fails
  m + (4 to "four") // Doesn't change m
  m eq mapOf(5 to "five", 6 to "six")
  val m2 = m + (4 to "four")
  m2 eq mapOf(
    5 to "five", 6 to "six", 4 to "four")
}

Die Definition von m erstellt eine Map, die Ints mit Strings verknüpft. Wenn wir versuchen, einen String zu ersetzen, gibt Kotlin einen Fehler aus.

Ein Ausdruck mit + erstellt eine neue Map, die sowohl die alten Elemente als auch das neue enthält, aber die ursprüngliche Map nicht beeinflusst. Die einzige Möglichkeit, ein Element zu einer unveränderlichen Map “hinzuzufügen”, besteht darin, eine neue Map zu erstellen.

Eine Map gibt null zurück, wenn sie keinen Eintrag für einen gegebenen Schlüssel enthält. Wenn Sie ein Ergebnis benötigen, das nicht null sein kann, verwenden Sie getValue() und fangen Sie NoSuchElementException ab, falls der Schlüssel fehlt:

// Maps/GetValue.kt
import atomictest.*

fun main() {
  val map = mapOf('a' to "attempt")
  map['b'] eq null
  capture {
    map.getValue('b')
  } eq "NoSuchElementException: " +
    "Key b is missing in the map."
  map.getOrDefault('a', "??") eq "attempt"
  map.getOrDefault('b', "??") eq "??"
}

getOrDefault() ist normalerweise eine angenehmere Alternative zu null oder einer Ausnahme.

Sie können Klasseninstanzen als Werte in einem Map speichern. Hier ist ein Map, das einen Contact anhand eines Zahlen-String abruft:

// Maps/ContactMap.kt
package maps
import atomictest.eq

class Contact(
  val name: String,
  val phone: String
) {
  override fun toString() =
    "Contact('$name', '$phone')"
}

fun main() {
  val miffy = Contact("Miffy", "1-234-567890")
  val cleo = Contact("Cleo", "098-765-4321")
  val contacts = mapOf(
    miffy.phone to miffy,
    cleo.phone to cleo)
  contacts["1-234-567890"] eq miffy
  contacts["1-111-111111"] eq null
}

Es ist möglich, Klasseninstanzen als Schlüssel in einer Map zu verwenden, aber das ist komplizierter, daher besprechen wir es später im Buch.

• -

Maps sehen aus wie einfache kleine Datenbanken. Sie werden manchmal assoziative Arrays genannt, weil sie Schlüssel mit Werten verknüpfen. Obwohl sie im Vergleich zu einer voll ausgestatteten Datenbank ziemlich begrenzt sind, sind sie dennoch bemerkenswert nützlich (und weitaus effizienter als eine Datenbank).

Übungen und Lösungen finden Sie auf www.AtomicKotlin.com.