A Biblioteca Padrão do Kotlin fornece implementações para tipos básicos de coleções: conjuntos (sets), listas (lists) e mapas (maps). Um par de interfaces representa cada tipo de coleção:

Uma interface somente leitura que fornece operações para acessar os elementos da coleção.
Uma interface mutável que estende a interface somente leitura correspondente com operações de escrita: adicionar, remover e atualizar seus elementos.
Observe que uma coleção mutável não precisa ser atribuída a uma var. Operações de escrita em uma coleção mutável ainda são possíveis mesmo que ela esteja atribuída a uma val. A vantagem de atribuir coleções mutáveis a val é que você protege a referência da coleção mutável contra modificações. Com o tempo, à medida que seu código cresce e se torna mais complexo, torna-se ainda mais importante evitar modificações não intencionais nas referências. Use val sempre que possível para ter um código mais seguro e robusto. Se você tentar reatribuir uma coleção val, receberá um erro de compilação:

val numbers = mutableListOf("one", "two", "three", "four")
    numbers.add("five")   // this is OK
    println(numbers)
    //numbers = mutableListOf("six", "seven")      // compilation error

Os tipos de coleção somente leitura são covariantes. Isso significa que, se uma classe Rectangle herda de Shape, você pode usar uma List<Rectangle> em qualquer lugar onde List<Shape> for exigida. Em outras palavras, os tipos de coleção têm a mesma relação de subtipo que os tipos de elemento. Map é covariante no tipo de valor, mas não no tipo de chave.

Por outro lado, coleções mutáveis não são covariantes; caso contrário, isso levaria a falhas em tempo de execução. Se MutableList<Rectangle> fosse um subtipo de MutableList<Shape>, você poderia inserir outros herdeiros de Shape (por exemplo, Circle) nela, violando assim seu argumento de tipo Rectangle.

Abaixo está um diagrama das interfaces de coleção do Kotlin:

Coleção

Collection<T> é a raiz da hierarquia de coleções. Essa interface representa o comportamento comum de uma coleção somente leitura: obter o tamanho, verificar pertencimento de itens e assim por diante. Collection herda da interface Iterable<T>, que define as operações para iterar elementos. Você pode usar Collection como parâmetro de uma função que se aplica a diferentes tipos de coleção. Para casos mais específicos, use os herdeiros de Collection: List e Set.

fun printAll(strings: Collection<String>) {
    for(s in strings) print("$s ")
    println()
}

fun main() {
    val stringList = listOf("one", "two", "one")
    printAll(stringList)

    val stringSet = setOf("one", "two", "three")
    printAll(stringSet)
}

Tipos de Collections em Kotlin

1. List

A List mantém a ordem dos elementos e permite valores repetidos.

fun main() {

    val frutas = listOf(
        "Maçã",
        "Banana",
        "Banana",
        "Uva"
    )

    println(frutas)
}

Acessando elementos da List

fun main() {

    val nomes = listOf(
        "Ana",
        "Carlos",
        "Pedro"
    )

    println(nomes[0])
    println(nomes[1])
}

Métodos importantes da List

fun main() {

    val numeros = listOf(10, 20, 30)

    println(numeros.size)
    println(numeros.first())
    println(numeros.last())
    println(numeros.contains(20))
}

MutableList

A List comum é somente leitura.

Para modificar a lista usamos MutableList

fun main() {

    val nomes = mutableListOf(
        "Rafael",
        "Maria"
    )

    nomes.add("Pedro")
    nomes.remove("Maria")

    println(nomes)
}

2. Set

Set armazena elementos únicos. Não permite duplicação.

fun main() {

    val numeros = setOf(
        1,
        2,
        3,
        3,
        4
    )

    println(numeros)
}

MutableSet

fun main() {

    val letras = mutableSetOf("A", "B")

    letras.add("C")
    letras.add("A")

    println(letras)
}

3. Map

Map trabalha com chave e valor (key -> value).

fun main() {

    val usuarios = mapOf(
        "rafael" to 25,
        "maria" to 30,
        "pedro" to 22
    )

    println(usuarios)
}

Acessando valores do Map

fun main() {

    val usuarios = mapOf(
        "rafael" to 25,
        "maria" to 30
    )

    println(usuarios["rafael"])
}

MutableMap

fun main() {

    val produtos = mutableMapOf(
        "Mouse" to 100,
        "Teclado" to 200
    )

    produtos["Monitor"] = 900
    produtos["Mouse"] = 150

    println(produtos)
}

ArrayDeque

Kotlin também possui ArrayDeque, usado como:

• fila
• pilha
• deque

fun main() {

    val deque = ArrayDeque<Int>()

    deque.addFirst(1)
    deque.addLast(2)
    deque.addLast(3)

    println(deque)
}

Boas práticas

A comunidade Kotlin recomenda:

• preferir collections read-only
• usar mutable apenas quando necessário

Documentação oficial.