Lists

Three names is fine. Three hundred is not.

Say you are storing the players in a game:

1val player1 = "Ada"
2val player2 = "Alan"
3val player3 = "Grace"

That is survivable. Now write the code that prints all of them. Then the code that counts them. Then add a fourth player while the game is running.

You cannot. Every one of those jobs needs to talk about "all the players" as a single thing, and three separate names is three separate things that merely look related.

A list is one name holding many values, kept in order:

val players = listOf("Ada", "Alan", "Grace")

One name. Countable, walkable, printable, passable to a function. This is the shape almost all real app data has — a list of notes, a list of messages, a list of scores.

Making one and looking inside

1val names = listOf("Ada", "Alan", "Grace")
2println(names.size)      // 3
3println(names[0])        // Ada
4println(names[2])        // Grace

listOf(...) builds a list from the values you give it. Each value is an element.

The square brackets reach in by position. That position is called the index, and — this is the part to memorise —

The first element is at index 0.

So a list of 3 has indexes 0, 1 and 2. There is no index 3. The last index is always size - 1, which is why this line turns up everywhere:

println(names[names.size - 1])   // Grace

Kotlin has kinder ways to say the same thing:

1println(names.first())    // Ada
2println(names.last())     // Grace

1val names = listOf("Ada", "Alan", "Grace")
2println(names[3])

Walking through it

A for loop over a list needs no numbers at all:

1for (name in names) {
2  println(name)
3}

Read it as "for each name in names". Each pass, name holds the next element. It stops by itself at the end, so it can never run off the edge.

When you genuinely need the position too, indices gives you the valid range:

1for (i in names.indices) {
2  println("$i: ${names[i]}")
3}

names.indices for a list of 3 is 0..2 — exactly the legal positions, worked out for you. Prefer this over 0 until names.size; it says the same thing and cannot be got wrong.

Lists that can change

listOf gives you a read-only list. There is no add, no remove, and names[0] = "X" is refused with No set method providing array access. That is deliberate: most lists never need to change, and one that cannot change cannot be changed by accident.

When you do need to add and remove, ask for a MutableList:

1val todo = mutableListOf("Wash up")
2todo.add("Feed cat")
3todo.add("Do homework")
4todo.removeAt(0)
5todo.remove("Feed cat")
6println(todo)       // [Do homework]

The useful ones:

• add(item) puts an item on the end.
• removeAt(index) removes by position.
• remove(item) removes the first match by value.
• clear() empties it.

1val a = mutableListOf(1)
2a.add(2)          // fine — changing the list
3// a = mutableListOf(3)   // refused — changing the name

Questions you can ask a list

These work on any list, changeable or not:

1println(names.isEmpty())          // false
2println("Ada" in names)           // true
3println(names.indexOf("Alan"))    // 1
4println(names.joinToString(", "))

in is the readable way to ask "is this in there?". indexOf gives the position, or -1 if it is not present — check for -1 before using the answer as an index. And joinToString turns a list into one tidy String, which beats printing the raw list when a person has to read it.

Every list also knows its type. listOf("Ada", "Alan") is a List<String>, and you cannot put a number in it — the same type checking you met in Lesson 1.2, applied to collections.

The whole lesson in one program