Kotlin Maps and Sets

val prices = mapOf("tea" to 2.5, "cake" to 3.75, "soup" to 4.0)
println(prices["tea"])                   // 2.5
println(prices["pizza"])                 // null
println(prices.getOrDefault("pizza", 0.0))  // 0.0

• "tea" to 2.5 creates a pair: the key and its value.
• map[key] returns the value, or null if the key isn't there, so its type is nullable (Double?).
• getOrDefault(key, fallback), or map[key] ?: fallback, gives a safe default.
• Keys are unique; values can repeat.
• "tea" in prices checks whether a key exists. keys, values and size describe the map.

val stock = mutableMapOf("pen" to 300, "notebook" to 120)
stock["ruler"] = 50          // add a new entry
stock["pen"] = 280           // update an existing one
stock.remove("notebook")     // remove by key
stock["pen"] = (stock["pen"] ?: 0) - 1

Setting a value with map[key] = value adds the key if it's new and replaces the value if it exists. getOrPut(key) { default } returns the existing value, or adds the default and returns it, which is handy for building up maps of lists.

Loop over entries and unpack each one into a key and a value:

for ((item, price) in prices) {
    println("$item costs $price")
}

Maps are the classic tool for counting. Start each new key at zero and add one:

val counts = mutableMapOf<String, Int>()
for (word in words) {
    counts[word] = (counts[word] ?: 0) + 1
}

Kotlin's groupingBy { it }.eachCount() does the same in one line, as the next lesson shows. mapOf keeps entries in the order they were inserted, so output is predictable.

val tags = mutableSetOf("kotlin", "android")
tags.add("kotlin")         // ignored: already there
println(tags)              // [kotlin, android]

Checking x in set is very fast, even for huge sets, which makes sets ideal for "have we seen this?" checks.

Read-only maps have functions that return new maps, just like lists do. Inside the lambda, it is one entry with a key and a value:

val prices = mapOf("tea" to 2.5, "cake" to 3.75, "soup" to 4.0)

prices.filterValues { it > 3.0 }          // {cake=3.75, soup=4.0}
prices.mapValues { it.value * 2 }         // {tea=5.0, cake=7.5, soup=8.0}
prices.mapKeys { it.key.uppercase() }     // {TEA=2.5, CAKE=3.75, SOUP=4.0}
prices.toSortedMap()                      // {cake=3.75, soup=4.0, tea=2.5}
prices.maxBy { it.value }.key             // soup
prices + ("jam" to 1.0)                   // a new map with jam added
prices - "tea"                            // a new map without tea

filterKeys works like filterValues, and plain filter gives you the whole entry when you need both parts. toSortedMap() orders the entries by key, which is handy for printing a report alphabetically.

You can also build a map from a list, without a loop:

val words = listOf("kiwi", "fig", "banana")
words.associateWith { it.length }   // {kiwi=4, fig=3, banana=6}
words.associateBy { it.first() }    // {k=kiwi, f=fig, b=banana}

associateWith uses each item as a key and computes a value; associateBy computes a key and keeps the item as the value. If two items produce the same key, the later one wins, so associateBy silently drops data when keys clash.

Most of the time map[key] returning null is exactly what you want. Sometimes, though, a missing key means a bug, and you'd rather find out immediately. getValue(key) returns a non-null value or throws a NoSuchElementException with the message "Key pizza is missing in the map.".

Sets have a similar convenience: add returns true if the item was new and false if it was already there. That lets you check and record in one step:

val seen = mutableSetOf<String>()
if (!seen.add(email)) println("Duplicate: $email")