Maps and Sets

When a list is the wrong shape

You are keeping score for a game night. Four players, four scores. A list can hold them:

1val names = listOf("Ada", "Alan", "Grace", "Zoe")
2val points = listOf(12, 9, 15, 4)

Now answer one question: how many points does Grace have?

You have to find Grace's index in the first list, then read the same index out of the second one. Two steps, two lists, and one gruesome bug waiting to happen — if you ever add a name without adding a score, every answer after Grace becomes wrong for ever.

The problem is not your code. The problem is that a list is the wrong shape for this job. You do not want positions. You want lookups.

A map is a lookup table

1val scores = mapOf("Ada" to 12, "Grace" to 15)
2println(scores["Grace"])
3println(scores["Zoe"])

That prints:

115
2null

Three new things are happening here.

mapOf builds a map. Every entry is written as key to value. That little word to is real Kotlin — it builds a pair, which is just two values glued together.

Square brackets look things up. scores["Grace"] does not mean "position Grace". It means "the value filed under Grace".

A missing key gives you null. Not a crash, not zero — null, which is Kotlin's word for there is nothing here. If you want a stand-in instead, the ?: operator supplies one:

println(scores["Zoe"] ?: 0)

That prints 0. Read ?: as "or else". Lesson 1.13 is entirely about null and this operator, so for now just take it as a handy fallback.

Keys are unique; values are not

Two players can both have fifteen points. No two entries can share a key. If you write the same key twice, the later one silently wins:

1val m = mapOf("Ada" to 12, "Ada" to 15)
2println(m.size)
3println(m["Ada"])

That prints 1 then 15. There is only ever one Ada slot.

Walking through every entry

A for loop over a map hands you both halves at once:

1for ((name, score) in scores) {
2  println("$name scored $score")
3}

The double brackets around (name, score) are destructuring — unpacking one entry into two names in a single move. Lesson 1.15 uses the same trick on your own types.

If you only want one half, scores.keys and scores.values give you each side on its own.

Changing a map

mapOf builds a read-only map. To add and remove entries you want a mutable one:

1val scores = mutableMapOf("Ada" to 12)
2scores["Zoe"] = 4        // add
3scores["Ada"] = 15       // replace
4scores.remove("Zoe")     // delete
5println(scores.containsKey("Ada"))
6println("Zoe" in scores)

That prints true then false. Note that in works on a map's keys, and reads almost like English.

A set holds each thing once

1val tags = setOf("red", "blue", "red")
2println(tags.size)
3println("blue" in tags)

That prints 2 then true. The second "red" was simply absorbed.

A set has no positions, so tags[0] is not a thing you can write — the compiler rejects it. In exchange you get two superpowers:

• Instant membership tests. "blue" in tags is fast even with a hundred thousand tags.
• Free de-duplication. .toSet() on any collection throws the repeats away.

1val rolls = listOf(6, 4, 6, 2, 4)
2println(rolls.toSet())

That prints [6, 4, 2] — each face once, in the order it was first seen.

mutableSetOf gives you add and remove. add hands back true if the item was new and false if it was already there, which is a tidy way to ask "have I seen this before?"

Which one when

You will use all three in Part 5. Pocket Notes stores notes in a list because order matters. Focus Flow looks up a session's settings by name in a map. And a "which days did I focus?" question is a set, because a day either counts or it does not.

1Ada: 15
2Alan: 9
3Players: 2
4Faces seen: [6, 4, 2]