Collections and Lambdas

Often in programming, we need to deal with collections of stuff. If you have worked with any major programming language, you will have dealt with collection types, such as:

• arrays or lists
• sets (collections of distinct unequal objects)
• maps (collections of key/value pairs)

Kotlin has these as well. Learning how to use them not only involves dealing with the actual types, but also with how to perform common operations on them, such as iterating over their contents.

Major Collection Types and Creation Functions

Kotlin has the aforementioned roster of collection types, and they form the most common collection types that you will use.

Kotlin/JVM also has access to other standard Java collection types, like LinkedHashMap, which we will discuss later in this chapter. However, usually you will use those only if there is no native Kotlin equivalent.

Arrays

Kotlin has an Array class that is analogous to Java arrays. If you use Kotlin arrays, and you are running on Kotlin/JVM, your Kotlin arrays will be mapped to Java arrays.

Overall, arrays are not quite as popular in Kotlin as are lists. However, you are welcome to use them, and they may be necessary if your code is going to interoperate with Java code.

To create an array, the simplest approach is to use the arrayOf() utility function:

  val things = arrayOf("foo", "bar", "goo")

  println(things::class)
  println(things)

Running this in the Klassbook gives us:

class Array
foo,bar,goo

Typed Arrays

Kotlin also has dedicated classes for arrays of primitive types:

• BooleanArray
• ByteArray
• CharArray
• DoubleArray
• FloatArray
• IntArray
• LongArray
• ShortArray

They have corresponding utility functions to create instances, such as intArrayOf():

  val things = intArrayOf(1, 3, 3, 7)

  println(things::class)
  println(things)

class IntArray
1,3,3,7

As with Array, these type-specific arrays are not especially popular, except where you might need them for working with Java code that expects those primitive array types.

Lists

The basic one-dimensional collection type in Kotlin is the list. This is analogous to a Java ArrayList.

You can create instances of a list via listOf(), much like you create arrays with arrayOf() and the others mentioned above:

  val things = listOf("foo", "bar", "goo")

  println(things::class)
  println(things)

Technically, List is an interface. The concrete implementation that we see will be an ArrayList:

class ArrayList
[foo, bar, goo]

An unusual aspect of lists is that listOf() creates an “immutable” list, one where we cannot replace items in the list. We will explore immutability more later in this chapter.

Sets

Many programming languages offer a “set” collection type, which is a one-dimensional collection in which only distinct objects will be included. For example, if you try adding the four numbers 1, 3, 3, 7 to a list, you would have four entries, but adding them to a set results in a three-element set holding 1, 3, 7. The duplicate 3 value is ignored.

Kotlin has first-class support for sets, created using setOf():

  val things = setOf(1, 3, 3, 7)

  println(things::class)
  println(things)
  println(things.size)

As with List, Set is an interface. The concrete implementation that you will get from setOf() is a LinkedHashSet:

class LinkedHashSet
[1, 3, 7]
3

Among other stuff, this code snippet prints out the size of things. size is a property of a Set (and of List, for that matter), providing the number of elements in the collection. Here we see that the duplicate 3 values were replaced by a single 3 in the Set.

And, as with lists, setOf() creates an immutable Set, which we will cover later in this chapter.

Maps

Most programming languages have some support for a “map” or “dictionary” type, representing a key-value store. You can then place data into the collection as key-value pairs, to be able to eventually retrieve values given their keys. In Kotlin, we have a Map type that fills this role.

To create a hard-coded map — the way we have created hard-coded lists and sets — you can use the mapOf() utility function. This takes a comma-delimited list of key-value pairs, where the key and value are separated by the to keyword:

  val things = mapOf("key" to "value", "other-key" to "other-value")

  println(things::class)
  println(things)
  println(things.size)

Of course, you can combine these constructs, such as having a map of lists:

  val things = mapOf("odd" to listOf(1, 3, 5, 7, 9), "even" to listOf(2, 4, 6, 8))

  println(things::class)
  println(things)
  println(things.size)

(in truth, to is actually a function, leveraging some special syntax that we will see much later in the book)