Usar coleções em Kotlin

1. Introdução

Em muitos apps, é provável que você já tenha visto dados mostrados como uma lista: contatos, configurações, resultados de pesquisa etc.

9fbd3bf7cb6adc72.png

No entanto, no código programado 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 envolvendo quantidades arbitrárias de dados, você precisa aprender a usar coleções.

Os tipos de coleção, à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. A capacidade de 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

  • Conhecer a programação em 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 vai ser 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 um número arbitrário 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.

960e34f4c96e2fd9.png

  • 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 do elemento inicial em 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.

5baf880a3670720d.png

Na memória do dispositivo, os elementos na matriz são armazenados próximos uns dos 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 as matrizes têm acesso aleatório.
  • Uma matriz tem um tamanho fixo. Isso significa que não é possível adicionar elementos a uma matriz além desse 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.

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

9d5c8c00b30850cb.png

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 você viu 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 observar matrizes em ação com uma pequena exploração do sistema solar.

  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")
  1. Como o Kotlin usa a inferência de tipo, você pode omitir o nome do tipo chamando 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")
  1. 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
  1. Execute o programa para verificar se ele funciona. Você ainda não vai ter uma saída.

Acessar um elemento em uma matriz

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

1f8398eaee30c7b0.png

Isso é chamado de sintaxe de subscrito. Ela é 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 exiba 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])
  1. 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.

9469e321ed79c074.png

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 modificação 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"
  1. Imprima o elemento no índice 3.
println(solarSystem[3])
  1. Execute o programa. O quarto elemento da matriz (no índice 3) é atualizado.
...
Little Earth
  1. Agora, vamos supor que os cientistas fizeram uma descoberta de que há 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"
  1. Execute o código. Uma exceção ArrayIndexOutOfBounds é gerada. Como a matriz já tem oito elementos, 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
  1. Remova Plutão da matriz.

Código a ser removido

solarSystem[8] = "Pluto"
  1. Se você quiser aumentar uma matriz, precisa criar uma nova. Defina uma nova variável chamada 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")
  1. Agora, tente imprimir o elemento no índice 8.
println(newSolarSystem[8])
  1. 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.

Espere um pouco. Embora as matrizes sejam um dos aspectos fundamentais da programação, usar uma 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 é algo exatamente simples e direto, e 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 seções a seguir, 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 as situações em que esses tipos de coleção serão usados.

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.

a4970d42cd1d2b66.png

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

27afd8dd880e1ae5.png

É assim que elementos podem ser adicionados e removidos de listas. Na maioria dos casos, leva o mesmo tempo para adicionar qualquer elemento a uma lista, independentemente de quantos elementos existam nela. Se a adição de um novo elemento colocar a matriz acima do tamanho definido, pode ser necessário mover elementos e abrir espaço para novos. As listas fazem tudo isso para você, mas nos bastidores, é simplesmente uma matriz sendo trocada 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 para uma classe implementar. 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 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 amplia determinar como cada propriedade e método é implementado. A implementação baseada em matriz descrita acima é a que você vai usar com mais frequência, se não sempre. No entanto, o Kotlin permite que outras classes ampliem a List e a 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 de main().
  2. Em main(), crie uma List de planetas com o nome solarSystem chamando listOf().
fun main() {
    val solarSystem = listOf("Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune")
}
  1. A List tem uma propriedade size para conseguir o número de elementos na lista. Imprima o size da lista solarSystem.
println(solarSystem.size)
  1. 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. Imprima o planeta no índice 2 usando a sintaxe de subscrito.
println(solarSystem[2])
  1. Imprima o elemento no índice 3 chamando get() na lista solarSystem.
println(solarSystem.get(3))
  1. Execute o código. O elemento no índice 2 é "Earth", e o elemento no índice 3 é "Mars".
...
Earth
Mars

Além de receber um elemento pelo índice dele, você também pode pesquisar o índice de um elemento específico usando o método indexOf(). Esse método 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. Imprima o resultado de chamar o indexOf() na lista solarSystem, transmitindo "Earth".
println(solarSystem.indexOf("Earth"))
  1. Chame o indexOf(), transmitindo "Pluto" e imprima o resultado.
println(solarSystem.indexOf("Pluto"))
  1. Execute o código. Um elemento corresponde a "Earth", então o índice 2 é impresso. Não há um elemento que corresponda a "Pluto", então -1 é impresso.
...
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.

Uma tarefa comum na programação é realizar uma tarefa para cada elemento de uma lista. O Kotlin inclui um recurso chamado repetição for para fazer isso com uma sintaxe concisa e legível. Geralmente, isso é chamado de repetição ou iteração de uma lista.

1245a226a9ceeba1.png

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 seguido pela palavra-chave in e pelo nome da coleção. Depois dos parênteses de fechamento, temos as chaves, em que você inclui o código que quer executar para cada elemento na coleção. Isso é conhecido como corpo da repetição. Cada vez que esse código é executado, ele é conhecido como iteração.

A variável antes da palavra-chave in não é declarada com val ou var. Presume-se que ela seja somente de acesso. Ela pode ser nomeada como você quiser. 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 iteração e assim por diante. Essa variável fica dentro das chaves.

Para observar isso em ação, imprima 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) {
}
  1. Dentro das chaves, imprima o valor de planet usando println().
for (planet in solarSystem) {
    println(planet)
}
  1. 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 iria querer a habilidade de 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 o adiciona ao final da lista.
  • A outra versão de add() tem dois parâmetros. O primeiro corresponde a um índice em que o novo elemento deve ser inserido. O segundo é o elemento que está sendo adicionado à lista.

Vamos ver tudo funcionando.

  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")
  1. 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")
  1. 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"
  1. Imprima o valor nos índices 3 e 9 usando a sintaxe de subscrito.
println(solarSystem[3])
println(solarSystem[9])
  1. Execute o código para verificar o resultado.
Future Moon
Pluto

Remover elementos de uma lista

Os elementos são removidos usando o método remove() ou removeAt(). Um elemento pode ser removido ao ser transmitido para o método remove() ou pelo índice dele usando removeAt().

Vamos observar 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)
  1. 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")
  1. A List fornece o método contains(), que retorna um Boolean caso um elemento exista em uma lista. Imprima o resultado da chamada de contains() para "Pluto".
println(solarSystem.contains("Pluto"))
  1. Para ter uma sintaxe ainda mais concisa, use o operador in. É possível verificar se um elemento 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)
  1. Execute o código. As duas instruções precisam imprimir false.
...
false
false

4. Conjuntos

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

ce127adf37662aa4.png

Como é possível criar uma coleção como essa? O segredo é um código hash. Esse código é uma Int produzida 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.

84842b78e78f2f58.png

Os conjuntos têm duas propriedades importantes:

  1. Em comparação com as listas, a pesquisa de um elemento específico em um conjunto é rápida, especialmente para coleções grandes. Embora o indexOf() de uma List exija a verificação de cada elemento desde o início até uma correspondência ser encontrada, em média, a mesma quantidade de tempo é necessária para verificar se um elemento está em um conjunto, seja ele o primeiro ou o milionésimo.
  2. Conjuntos tendem a 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.

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. No caso de grandes quantidades de dados, ele é recomendado para verificar se um elemento já existe em uma lista, o que exige a iteração em todos os elementos.

Assim como 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.

691f995fde47f1ff.png

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 de 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")
  1. Imprima o tamanho do conjunto usando a propriedade size.
println(solarSystem.size)
  1. Assim como a List, o 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")
  1. Imprima o size do conjunto depois de adicionar o elemento.
println(solarSystem.size)
  1. 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"))
  1. Execute o código. O tamanho aumentou e contains() agora retorna true.
8
9
true
  1. Como mencionado anteriormente, os conjuntos não podem conter cópias. Tente adicionar "Pluto" novamente.
solarSystem.add("Pluto")
  1. Imprima o tamanho do conjunto novamente.
println(solarSystem.size)
  1. 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() usa um único parâmetro e remove o elemento especificado do conjunto.

  1. Use a função remove() para remover "Pluto".
solarSystem.remove("Pluto")
  1. Imprima o tamanho da coleção e chame contains() novamente para verificar se "Pluto" ainda está no conjunto.
println(solarSystem.size)
println(solarSystem.contains("Pluto"))
  1. 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 chamados de key-value pair.

8571494fb4a106b6.png

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.

affc23a0e1f2b223.png

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 pelo valor. Cada par é separado por uma vírgula.

8719ffc353f652f.png

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

  1. Remova o código já existente de main().
  2. Crie um mapa chamado solarSystem usando mutableMapOf() com valores iniciais, conforme mostrado.
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
)
  1. Assim como listas e conjuntos, o Map fornece uma propriedade size, contendo o número de pares de chave-valor. Imprima o tamanho do mapa solarSystem.
println(solarSystem.size)
  1. 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
  1. Imprima o tamanho novamente depois de inserir o elemento.
println(solarSystem.size)
  1. É possível usar a sintaxe de subscrito para receber um valor. Imprima o número de luas para a chave "Pluto".
println(solarSystem["Pluto"])
  1. 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, ele vai retornar um valor nulo. Imprima o número de luas para "Theia".
println(solarSystem["Theia"])
  1. Execute o código. O número de luas de Plutão será impresso. 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. Imprima o resultado da chamada de remove() e da transmissão para "Pluto".
solarSystem.remove("Pluto")
  1. Para verificar se o item foi removido, imprima o tamanho novamente.
println(solarSystem.size)
  1. Execute o código. Após a remoção da entrada, o tamanho do mapa será 8.
...
8
  1. A sintaxe de subscrito, ou o método put(), também pode modificar um valor de uma chave que já existe. Use essa sintaxe para atualizar as luas de Júpiter para 78 e imprimir o novo valor.
solarSystem["Jupiter"] = 78
println(solarSystem["Jupiter"])
  1. Execute o código. O valor da chave atual, "Jupiter", é atualizado.
...
78

6. Conclusão

Parabéns! Você aprendeu sobre um dos tipos de dados mais básicos em programação, a matriz e vários tipos de coleção convenientes criados com base em matrizes, incluindo List, Set e Map. Esses tipos de coleção permitem agrupar e organizar os valores no código. As matrizes e listas fornecem 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 observar esses tipos de coleção sendo usados com frequência em apps futuros. Saber como eles podem ser usados vai ajudar na sua carreira de programação.

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)