Usar coleções em Kotlin

1. Introdução

É provável que você já tenha encontrado dados sendo mostrados como uma lista em vários apps, como de contatos, configurações, resultados de pesquisa etc.

No entanto, nos códigos criados até agora, você trabalhou principalmente com dados com um único valor, como um número ou um trecho de texto mostrado na tela. Para criar apps que envolvam quantidades arbitrárias de dados, é necessário aprender a usar coleções.

Os tipos de coleções, às vezes chamados de estruturas de dados, permitem armazenar diversos valores de maneira organizada, geralmente do mesmo tipo de dado. Uma coleção pode ser uma lista ordenada, um agrupamento de valores exclusivos ou uma associação de valores de um tipo de dado a outro. Usar coleções de forma eficaz permite que você implemente recursos comuns de apps Android, como listas de rolagem, e resolva vários problemas de programação reais que envolvem quantidades arbitrárias de dados.

Este codelab discute como trabalhar com diversos valores no código e introduz uma variedade de estruturas de dados, incluindo matrizes, listas, conjuntos e mapas.

Pré-requisitos

• Conhecimento sobre a programação Kotlin orientada a objetos, incluindo classes, interfaces e genéricos.

O que você vai aprender

• Como criar e modificar matrizes.
• Como usar List e MutableList.
• Como usar Set e MutableSet.
• Como usar Map e MutableMap.

O que é necessário

• Um navegador da Web com acesso ao Playground Kotlin.

2. Matrizes em Kotlin

O que é uma matriz?

Uma matriz é a maneira mais simples de agrupar uma quantidade arbitrária de valores nos seus programas.

Assim como um agrupamento de painéis solares é chamado de matriz solar, uma Array (matriz) representa mais de um valor. Uma matriz é uma sequência de valores que têm o mesmo tipo de dado.

• Uma matriz contém diversos valores chamados de elementos ou, às vezes, itens.
• Os elementos de uma matriz são ordenados e acessados com um índice.

O que é um índice? É um número inteiro que corresponde a um elemento na matriz. O índice informa a distância de um item em relação ao elemento inicial de uma matriz. Isso é chamado de indexação zero. O primeiro elemento da matriz está no índice 0, já o segundo está no índice 1, porque está a uma posição do primeiro, e assim por diante.

Na memória do dispositivo, os elementos na matriz são armazenados próximos uns aos outros. Os detalhes estão além do escopo deste codelab, mas há duas implicações importantes:

• O acesso a um elemento de matriz pelo índice é rápido. É possível acessar qualquer elemento aleatório de uma matriz pelo índice e esperar que leve o mesmo tempo para acessar qualquer outro elemento aleatório. É por isso que matrizes são conhecidas por terem acesso aleatório.
• Uma matriz tem um tamanho fixo. Isso significa que não é possível adicionar elementos a uma matriz que excedam esse tamanho. Tentar acessar o elemento no índice 100 em uma matriz de 100 elementos gera uma exceção, porque o índice mais alto é 99. Lembre-se de que o primeiro índice é 0, não 1. No entanto, é possível modificar os valores nos índices da matriz.

Observação: neste codelab, "memória" se refere à memória de acesso aleatório (RAM) de curto prazo do dispositivo, não ao armazenamento permanente de longo prazo. Ela é chamada de "acesso aleatório" porque permite acesso rápido a qualquer local arbitrário na memória.

Para declarar uma matriz no código, use a função arrayOf().

A função arrayOf() usa os elementos da matriz como parâmetros e retorna uma matriz do tipo correspondente aos parâmetros transmitidos. Isso pode ser um pouco diferente das outras funções que mostramos, porque arrayOf() tem um número variável de parâmetros. Se você transmitir dois argumentos para arrayOf(), a matriz resultante vai conter dois elementos, indexados em 0 e 1. Se você transmitir três argumentos, a matriz resultante vai ter três elementos, indexados de 0 a 2.

Vamos explorar um pouco o sistema solar para observar as matrizes em ação.

1. Acesse o Playground Kotlin.
2. Em main(), crie uma variável rockPlanets. Chame arrayOf(), transmitindo o tipo String com quatro strings, uma para cada um dos planetas rochosos do sistema solar.

val rockPlanets = arrayOf<String>("Mercury", "Venus", "Earth", "Mars")

3. Como o Kotlin usa a inferência de tipo, você pode omitir o nome do tipo ao chamar arrayOf(). Abaixo da variável rockPlanets, adicione outra variável gasPlanets sem transmitir um tipo entre os sinais de maior e menor.

val gasPlanets = arrayOf("Jupiter", "Saturn", "Uranus", "Neptune")

4. Você pode fazer algumas coisas interessantes com matrizes. Por exemplo, assim como os tipos numéricos Int ou Double, é possível adicionar duas matrizes juntas. Crie uma nova variável chamada solarSystem e a defina como o resultado de rockPlanets e gasPlanets usando o operador de adição (+). O resultado é uma nova matriz contendo todos os elementos das matrizes rockPlanets e gasPlanets.

val solarSystem = rockPlanets + gasPlanets

5. Execute o programa para conferir se ele funciona. Por enquanto, nada vai acontecer.

Acessar um elemento em uma matriz

É possível acessar um elemento de uma matriz pelo índice.

Isso é feito com a sintaxe de subscrito, que é composta por três partes:

• O nome da matriz.
• Um colchete de abertura ([) e de fechamento (]).
• O índice do elemento da matriz entre colchetes.

Vamos acessar os elementos da matriz solarSystem pelos índices deles.

1. Em main(), acesse e mostre cada elemento da matriz solarSystem. Observe como o primeiro índice é 0 e o último é 7.

println(solarSystem[0])
println(solarSystem[1])
println(solarSystem[2])
println(solarSystem[3])
println(solarSystem[4])
println(solarSystem[5])
println(solarSystem[6])
println(solarSystem[7])

2. Execute o programa. Os elementos estão na mesma ordem em que você os listou ao chamar arrayOf().

Mercury
Venus
Earth
Mars
Jupiter
Saturn
Uranus
Neptune

Você também pode definir o valor de um elemento da matriz pelo índice.

O acesso ao índice é o mesmo de antes: o nome da matriz, seguido pelo índice entre colchetes. Isso é seguido pelo operador de atribuição (=) e por um novo valor.

Vamos praticar a mudança de valores na matriz solarSystem.

1. Vamos dar um novo nome ao planeta Marte para a futura colonização humana. Acesse o elemento no índice 3 e o defina como "Little Earth".

solarSystem[3] = "Little Earth"

2. Mostre o elemento no índice 3.

println(solarSystem[3])

3. Execute o programa. O quarto elemento da matriz (no índice 3) vai ser atualizado.

...
Little Earth

4. Agora, vamos supor que os cientistas descobriram um nono planeta além de Netuno, chamado Plutão. Mencionamos que não é possível redimensionar uma matriz. O que aconteceria se você tentasse? Tente adicionar Plutão à matriz solarSystem. Faça isso no índice 8, que é o nono elemento da matriz.

solarSystem[8] = "Pluto"

5. Execute o código. Uma exceção ArrayIndexOutOfBounds é gerada. A matriz já tem oito elementos, então, como esperado, não é possível simplesmente adicionar um nono.

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 8 out of bounds for length 8

6. Remova Plutão da matriz.

Código a ser removido

solarSystem[8] = "Pluto"

7. Se você quiser aumentar uma matriz, precisa criar uma nova. Defina uma nova variável com o nome newSolarSystem, conforme mostrado. Essa matriz pode armazenar nove elementos em vez de oito.

val newSolarSystem = arrayOf("Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune", "Pluto")

8. Agora, tente mostrar o elemento no índice 8.

println(newSolarSystem[8])

9. Execute o código e observe que ele é executado sem exceções.

...
Pluto

Muito bem! Com o conhecimento sobre matrizes, é possível fazer quase tudo com as coleções.

Mas espere um pouco. Embora as matrizes sejam um dos aspectos fundamentais da programação, usar uma matriz para tarefas que exigem a adição e remoção de elementos, a exclusividade em uma coleção ou a associação de objetos a outros não é tão simples e direto. O código do app ficaria confuso rapidamente.

É por isso que a maioria das linguagens de programação, incluindo Kotlin, implementa tipos especiais de coleções para lidar com situações que costumam ocorrer em apps reais. Nas próximas seções, você vai aprender sobre três coleções comuns: List, Set e Map. Você também vai conhecer as propriedades e os métodos comuns e em que situações usar esses tipos de coleções.

3. Listas

Uma lista é uma coleção redimensionável ordenada, geralmente implementada como uma matriz redimensionável. Quando a matriz está totalmente preenchida e você tenta inserir um novo elemento, ela é copiada para uma nova matriz maior.

Com uma lista, você também pode inserir novos elementos entre os já existentes em um índice específico.

É assim que elementos podem ser adicionados e removidos de listas. Na maioria dos casos, o tempo necessário para adicionar qualquer elemento a uma lista é o mesmo, independente de quantos elementos existam nela. Caso a adição de um novo elemento faça com que a matriz exceda o tamanho definido, pode ser necessário mover elementos e abrir espaço para novos. As listas fazem tudo isso para você. Internamente, o que acontece é a troca de uma matriz antiga por uma nova quando necessário.

List e MutableList

Os tipos de coleção que você vai encontrar em Kotlin implementam uma ou mais interfaces. Como você aprendeu no codelab Genéricos, objetos e extensões desta unidade, as interfaces oferecem um conjunto padrão de propriedades e métodos a serem implementados por uma classe. Uma classe que implementa a interface List fornece implementações para todos os métodos e propriedades da interface List. O mesmo acontece com MutableList.

O que List e MutableList fazem?

• A List é uma interface que define propriedades e métodos relacionados a uma coleção ordenada de itens somente leitura.
• A MutableList amplia a interface List definindo métodos para modificar uma lista, como a adição e remoção de elementos.

Essas interfaces só especificam as propriedades e os métodos de uma List e/ou uma MutableList. Cabe à classe que as usam determinar como as propriedades e métodos são implementados. A implementação baseada em matriz descrita acima é a que você vai usar com mais frequência, talvez sempre. No entanto, o Kotlin permite que outras classes usem List e MutableList.

A função listOf()

Como arrayOf(), a função listOf() usa os itens como parâmetros, mas retorna uma List em vez de uma matriz.

1. Remova o código já existente da função main().
2. Em main(), chame listOf() para criar uma List de planetas com o nome solarSystem.

fun main() {
    val solarSystem = listOf("Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune")
}

3. A List tem uma propriedade size para extrair o número de elementos na lista. Mostre o size da lista solarSystem.

println(solarSystem.size)

4. Execute o código. O tamanho da lista precisa ser 8.

8

Acessar elementos de uma lista

Como acontece com uma matriz, é possível acessar um elemento em um índice específico de uma List usando a sintaxe de subscrito. Faça o mesmo usando o método get(). A sintaxe de subscrito e o método get() usam um Int como parâmetro e retornam o elemento nesse índice. Assim como a Array, ArrayList também tem uma indexação zero. Por exemplo, o quarto elemento fica no índice 3.

1. Mostre o planeta no índice 2 usando a sintaxe de subscrito.

println(solarSystem[2])

2. Mostre o elemento no índice 3 chamando get() na lista solarSystem.

println(solarSystem.get(3))

3. Execute o código. O elemento no índice 2 é "Earth" e o elemento no índice 3 é "Mars".

...
Earth
Mars

Além de acessar um elemento pelo índice dele, você também pode pesquisar o índice de um elemento específico usando o método indexOf(). O método indexOf() pesquisa um determinado elemento na lista, transmitido como um argumento, e retorna o índice da primeira ocorrência desse elemento. Se o elemento não aparecer na lista, ele vai retornar -1.

1. Mostre o resultado da chamada de indexOf() na lista solarSystem, transmitindo "Earth".

println(solarSystem.indexOf("Earth"))

2. Chame indexOf(), transmitindo "Pluto" e mostre o resultado.

println(solarSystem.indexOf("Pluto"))

3. Execute o código. Como um dos elementos corresponde a "Earth", o índice 2 é mostrado. Não há um elemento que corresponda a "Pluto", então, -1 é mostrado.

...
2
-1

Iterar os elementos da lista usando uma repetição for

Ao aprender sobre os tipos de função e as expressões lambda, você viu como usar a função repeat() para executar o código várias vezes.

Algo comum na programação é realizar uma tarefa para cada elemento de uma lista. O Kotlin inclui um recurso conhecido como repetição for que faz isso com uma sintaxe concisa e legível. Geralmente, esse processo é conhecido como repetição ou iteração de uma lista.

Para repetir uma lista, use a palavra-chave for, seguida de parênteses de abertura e fechamento. Dentro dos parênteses, inclua um nome de variável, seguida pela palavra-chave in e pelo nome da coleção. Depois dos parênteses de fechamento, insira as chaves. Dentro delas, você vai incluir o código que quer executar para cada elemento na coleção. Isso é conhecido como corpo da repetição. Uma iteração é o nome dado a cada execução do código da repetição.

A variável antes da palavra-chave in não é declarada com val ou var. Presume-se que ela seja somente de acesso. Você pode dar o nome que quiser a ela. Se uma lista recebe um nome no plural, como planets, é comum nomear a variável no singular, como planet. Também é comum nomear a variável como item ou element.

Ela vai ser usada como uma variável temporária correspondente ao elemento atual na coleção: o elemento no índice 0 para a primeira iteração, o elemento no índice 1 para a segunda e assim por diante. Essa variável fica dentro das chaves.

Para observar isso em ação, mostre cada nome de planeta em uma linha separada usando uma repetição for.

1. Na função main(), abaixo da chamada mais recente para println(), adicione uma repetição for. Dentro dos parênteses, nomeie a variável como planet e faça uma repetição na lista solarSystem.

for (planet in solarSystem) {
}

2. Dentro das chaves, mostre o valor de planet usando println().

for (planet in solarSystem) {
    println(planet)
}

3. Execute o código. O código no corpo da repetição é executado para cada item na coleção.

...
Mercury
Venus
Earth
Mars
Jupiter
Saturn
Uranus
Neptune

Adicionar elementos a uma lista

A capacidade de adicionar, remover e atualizar elementos de uma coleção é exclusiva das classes que implementam a interface MutableList. Se você estivesse monitorando planetas recém-descobertos, provavelmente gostaria de poder adicionar elementos a uma lista com frequência. É necessário chamar especificamente a função mutableListOf(), em vez de listOf(), ao criar uma lista em que você quer adicionar e remover elementos.

Há duas versões da função add():

• A primeira função add() tem um único parâmetro do tipo de elemento na lista e adiciona o elemento ao final da lista.
• A outra versão de add() tem dois parâmetros. O primeiro corresponde ao índice em que o novo elemento precisa ser inserido. O segundo é o elemento que está sendo adicionado à lista.

Vamos conferir como isso funciona.

1. Mude a inicialização do solarSystem para chamar mutableListOf() em vez de listOf(). Agora, você pode chamar métodos definidos na MutableList.

val solarSystem = mutableListOf("Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune")

2. Mais uma vez, podemos incluir Plutão como um planeta. Chame o método add() em solarSystem, transmitindo "Pluto" como o argumento.

solarSystem.add("Pluto")

3. Alguns cientistas teorizam que um planeta chamado Theia existia antes de colidir com a Terra e formar a Lua. Insira "Theia" no índice 3, entre "Earth" e "Mars".

solarSystem.add(3, "Theia")

Atualizar elementos em um índice específico

É possível atualizar os elementos já existentes com uma sintaxe de subscrito:

1. Atualize o valor no índice 3 para "Future Moon".

solarSystem[3] = "Future Moon"

2. Mostre o valor nos índices 3 e 9 usando a sintaxe de subscrito.

println(solarSystem[3])
println(solarSystem[9])

3. Execute o código para conferir o resultado.

Future Moon
Pluto

Remover elementos de uma lista

Os elementos são removidos usando o método remove() ou removeAt(). Para remover um item, você pode transmitir o elemento ao método remove() ou o índice dele a removeAt().

Vamos conferir os dois métodos para remover um elemento em ação.

1. Chame removeAt() em solarSystem, transmitindo 9 para o índice. Isso vai remover "Pluto" da lista.

solarSystem.removeAt(9)

2. Chame remove() em solarSystem, transmitindo "Future Moon" como o elemento a ser removido. Isso deve fazer uma pesquisa na lista e, se um elemento correspondente for encontrado, ele vai ser removido.

solarSystem.remove("Future Moon")

3. A List fornece o método contains(), que retorna um Boolean caso um elemento exista em uma lista. Mostre o resultado da chamada de contains() para "Pluto".

println(solarSystem.contains("Pluto"))

4. Para ter uma sintaxe ainda mais concisa, use o operador in. É possível verificar se um item está em uma lista usando o elemento, o operador in e a coleção. Use o operador in para verificar se solarSystem contém "Future Moon".

println("Future Moon" in solarSystem)

5. Execute o código. As duas instruções precisam mostrar false.

...
false
false

4. Conjuntos

Um conjunto é uma coleção que não tem uma ordem específica e não permite valores duplicados.

Como é possível criar uma coleção como essa? O segredo é um código hash. Esse código é um valor Int produzido pelo método hashCode() de qualquer classe Kotlin. Ele pode ser considerado um identificador semiexclusivo para um objeto Kotlin. Uma pequena mudança no objeto, como a adição de um caractere a uma String, resulta em um valor de hash muito diferente. Embora seja possível que dois objetos tenham o mesmo código hash, o que é chamado de colisão de hash, a função hashCode() garante certo grau de exclusividade. Quando há dois valores, geralmente cada um deles tem um código hash único.

Observação: um conjunto usa códigos hash como índices de matriz. Como pode haver cerca de 4 bilhões de códigos hash diferentes, um Set não é apenas uma matriz gigante. Em vez disso, considere um Set como uma matriz de listas.

A matriz externa (os números destacados em azul à esquerda) corresponde a um intervalo, também conhecido como bucket, de possíveis códigos hash. Cada lista interna (sombreadas em verde à direita) representa os itens individuais no conjunto. Como os conflitos de hash são relativamente incomuns, mesmo quando os possíveis índices são limitados, as listas internas em cada índice de matriz vão ter apenas um ou dois itens cada, a menos que dezenas ou centenas de milhares de elementos sejam adicionados.

Os conjuntos têm duas propriedades importantes:

1. Em comparação com listas, pesquisar um elemento específico em um conjunto é rápido, especialmente para coleções grandes. O método indexOf() em uma List exige a verificação de cada elemento desde o início até uma correspondência ser encontrada. Já para conjuntos, em média, a mesma quantidade de tempo é necessária para verificar se um elemento está na coleção, seja ele o primeiro ou o milionésimo.
2. Conjuntos costumam usar mais memória do que listas para a mesma quantidade de dados, já que mais índices de matriz costumam ser necessários do que os dados do conjunto.

Observação: ao contrário do que muitos pensam, o tempo necessário para verificar se um conjunto contém um elemento não é fixo e depende da quantidade de dados no conjunto. No entanto, como geralmente há poucas colisões de hash, o número de elementos que precisam ser verificados ainda é menor que a pesquisa de um item em uma lista.

A vantagem dos conjuntos é garantir a exclusividade. Se você estiver escrevendo um programa para monitorar planetas recém-descobertos, um conjunto vai oferecer uma maneira simples de verificar se um planeta já foi descoberto. Para casos em que há grandes quantidades de dados, é recomendado usar conjuntos, porque verificar se um elemento já existe em uma lista exige a iteração em todos os elementos.

Assim como há a List e a MutableList, há um Set e um MutableSet. O MutableSet implementa o Set, então qualquer classe que implemente MutableSet precisa implementar ambos.

Usar um MutableSet em Kotlin

Vamos usar um MutableSet no exemplo para demonstrar como adicionar e remover elementos.

1. Remova o código já existente da função main().
2. Crie um Set de planetas com o nome solarSystem usando mutableSetOf(). Isso retorna um MutableSet, cuja implementação padrão é LinkedHashSet().

val solarSystem = mutableSetOf("Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune")

3. Mostre o tamanho do conjunto usando a propriedade size.

println(solarSystem.size)

4. Assim como uma List, um Set também tem um método add(). Adicione "Pluto" ao conjunto solarSystem usando o método add(). É necessário apenas um parâmetro para o elemento adicionado. Os elementos nos conjuntos não têm necessariamente uma ordem, então não há um índice.

solarSystem.add("Pluto")

5. Mostre o size do conjunto depois de adicionar o elemento.

println(solarSystem.size)

6. A função contains() usa um único parâmetro e verifica se o elemento especificado está contido no conjunto. Em caso afirmativo, ele retorna verdadeiro. Caso contrário, ele retorna falso. Chame contains() para verificar se "Pluto" está em solarSystem.

println(solarSystem.contains("Pluto"))

7. Execute o código. O tamanho aumentou e contains() agora retorna true.

8
9
true

Observação: outra opção seria usar o operador in para verificar se um elemento está em uma coleção. Por exemplo: "Pluto" in solarSystem é equivalente a solarSystem.contains("Pluto").

8. Como mencionado anteriormente, os conjuntos não podem conter cópias. Tente adicionar "Pluto" novamente.

solarSystem.add("Pluto")

9. Mostre o tamanho do conjunto novamente.

println(solarSystem.size)

10. Execute o código novamente. "Pluto" não foi adicionado porque já está no conjunto. O tamanho não deve aumentar desta vez.

...
9

A função remove() recebe um único parâmetro e remove o elemento especificado do conjunto.

1. Use a função remove() para remover "Pluto".

solarSystem.remove("Pluto")

Observação: lembre-se de que os conjuntos são uma coleção não ordenada. Não há como remover um valor de um conjunto pelo índice dele, já que os conjuntos não têm índices.

2. Mostre o tamanho da coleção e chame contains() novamente para verificar se "Pluto" ainda está no conjunto.

println(solarSystem.size)
println(solarSystem.contains("Pluto"))

3. Execute o código. "Pluto" não está mais no conjunto, e o tamanho agora é 8.

...
8
false

5. Coleção de mapas

Um Map é uma coleção de chaves e valores. Nele, as chaves exclusivas são associadas a outros valores. Uma chave e o valor dela costumam ser conhecidos como key-value pair (par de chave-valor).

As chaves de um mapa são exclusivas. No entanto, os valores de um mapa não são. Duas chaves diferentes podem ser associadas ao mesmo valor. Por exemplo: "Mercury" tem 0 luas e "Venus" tem 0 luas.

Geralmente, acessar um valor por uma chave é mais rápido do que fazer uma pesquisa em uma lista grande, como com indexOf().

Os mapas podem ser declarados usando a função mapOf() ou mutableMapOf(). Eles precisam de dois tipos genéricos separados por vírgula: um para as chaves e outro para os valores.

Um mapa também pode usar a inferência de tipo se tiver valores iniciais. Para preencher um mapa com valores iniciais, cada par de chave-valor consiste na chave, seguida pelo operador to e, então, pelo valor. Os pares são separados por vírgula.

Vamos conferir em detalhes como usar mapas, algumas propriedades e métodos úteis.

1. Remova o código já existente da função main().
2. Crie um mapa com o nome solarSystem, usando mutableMapOf() com os valores iniciais, conforme mostrado no exemplo abaixo.

val solarSystem = mutableMapOf(
    "Mercury" to 0,
    "Venus" to 0,
    "Earth" to 1,
    "Mars" to 2,
    "Jupiter" to 79,
    "Saturn" to 82,
    "Uranus" to 27,
    "Neptune" to 14
)

3. Assim como listas e conjuntos, o Map fornece uma propriedade size, contendo o número de pares de chave-valor. Mostre o tamanho do mapa solarSystem.

println(solarSystem.size)

4. Você pode usar a sintaxe de subscrito para definir mais pares de chave-valor. Defina a chave "Pluto" como um valor 5.

solarSystem["Pluto"] = 5

5. Depois de inserir o elemento, mostre o tamanho novamente.

println(solarSystem.size)

6. É possível usar a sintaxe de subscrito para receber um valor. Mostre o número de luas para a chave "Pluto".

println(solarSystem["Pluto"])

7. Você também pode acessar valores com o método get(). Se você usar a sintaxe de subscrito ou chamar get(), é possível que a chave transmitida não esteja no mapa. Se não houver um par de chave-valor, o método vai retornar um valor nulo. Mostre o número de luas para "Theia".

println(solarSystem["Theia"])

8. Execute o código. O número de luas de Plutão vai ser mostrado. No entanto, como Theia não está no mapa, chamar get() retorna um valor nulo.

8
9
5
null

O método remove() remove o par de chave-valor com a chave especificada. Ele também vai retornar o valor removido, ou null, se a chave especificada não estiver no mapa.

1. Mostre o resultado da chamada de remove() e da transmissão para "Pluto".

solarSystem.remove("Pluto")

2. Para verificar se o item foi removido, mostre o tamanho novamente.

println(solarSystem.size)

3. Execute o código. Após a remoção da entrada, o tamanho do mapa vai ser 8.

...
8

4. A sintaxe de subscrito, ou o método put(), também pode modificar um valor de uma chave já existente. Use essa sintaxe para atualizar as luas de Júpiter para 78 e mostrar o novo valor.

solarSystem["Jupiter"] = 78
println(solarSystem["Jupiter"])

5. Execute o código. O valor da chave existente, "Jupiter", é atualizado.

...
78

6. Conclusão

Parabéns! Você aprendeu sobre um dos tipos de dados mais básicos em programação: a matriz. Além disso, aprendemos sobre vários tipos de coleções convenientes, criados com base em matrizes, incluindo List, Set e Map. Esses tipos de coleções permitem agrupar e organizar os valores no código. As matrizes e listas proporcionam acesso rápido aos elementos pelo índice, enquanto os conjuntos e mapas usam códigos hash para facilitar a localização de elementos na coleção. Você vai encontrar esses tipos de coleções sendo usados com frequência em apps futuros. Saber como eles podem ser usados vai ajudar na sua carreira como programador.

Resumo

• As matrizes armazenam dados ordenados do mesmo tipo e têm um tamanho fixo.
• As matrizes são usadas para implementar muitos dos outros tipos de coleções.
• As listas são uma coleção redimensionável e ordenada.
• Os conjuntos são coleções não ordenadas e não podem conter cópias.
• Os mapas funcionam de maneira semelhante a conjuntos e armazenam pares de chave-valor do tipo especificado.

7. Saiba mais (links em inglês)

• Coleções
• Lista
• Condições e repetições
• MutableList
• Set
• hashCode()
• MutableSet
• Mapa
• MutableMap