Today we'll examine how to use Kotlin's lists. We've stored sequential data before in an array, but lists are more flexible and more suited to certain tasks.
Like arrays, lists are an ordered data structure. However, unlike arrays, the size of a list can change as the program runs. This makes them much more appropriate for solving certain problems.
Kotlin has built-in lists. Let's see how they work! (Open up the documentation as you follow along...)
Lists v. Arrays
Like arrays, Kotlin
Lists store sequential data.
In Kotlin, the syntax for using
Lists is very similar to that for arrays, so it's easy sometimes to even not be sure what you are working with!
So let's review the array operations we're familiar with and show how they map onto
First, let's show how we create an array and
List, and check their size:
Note that with the
List, unlike the array we do not need to specify a size when we create the
This is because the size of a
List can change!
Next up, how do we initialize a list with a set of values and print its contents? Just like arrays, that's pretty easy!
We can access
List contents using bracket notation, just like with arrays:
ListAdd and Remove
Lists provide both an
add and a
remove method, and also support
+= syntax for append.
Let's explore how they work:
var list = mutableListOf(1, 2, 4)println(list)
Kotlin provides both mutable and immutable lists:
For now we'll focus on using mutable lists in our code, as we've been doing above. But we'll come back to this distinction later. For now, just keep this in mind, since it's easy to forget and create an immutable list and then try to modify it, which doesn't go well!
Note that the type for a Kotlin
List, but the type of a mutable list is
However, Kotlin will convert a
MutableList to a
The syntax that we introduce above is our first example of a Kotlin type parameter:
<String> on the right tells Kotlin that this list will store
If we wanted to store
Ints, we'd use
<Double>, and so on.
Why do lists require a type parameter? It's so that we can tell Kotlin what we are going to put in them! Once we do, Kotlin will help us avoid common mistakes:
These mistakes are also caught before you program is run, at a step called compilation that we'll explore later this week.
It's important to understand how to identify type parameters when examining Kotlin documentation. Let's do that together next.
Until this point, we've been using somewhat different approaches to creating arrays of
Strings versus Kotlin basic types, like
You'll notice a type parameter in the
String array, but no type parameter in the
Int array, rather a special
It turns out that we can also use
arrayOf<Int> in place of
The differences are subtle, but worth a brief discussion:
Don't worry too much about this at this point.
When you're working with
Int arrays, we'll be sure to specify which one to use when it matters.
And in general we'll begin to use Kotlin lists to solve more problems now, since they are more convenient that arrays.