Cómo usar colecciones en Kotlin

1. Introducción

En muchas apps, es probable que hayas visto datos que se muestran como una lista: contactos, parámetros de configuración, resultados de la búsqueda, etcétera.

Sin embargo, en el código que escribiste hasta el momento, trabajaste más con datos que consisten en un solo valor, como un número o una porción de texto que se muestra en la pantalla. Para compilar apps con cantidades arbitrarias de datos, debes aprender a usar las colecciones.

Los tipos de colección (a veces llamados estructuras de datos) te permiten almacenar varios valores, generalmente del mismo tipo de datos, de manera organizada. Una colección puede ser una lista ordenada, una agrupación de valores únicos o una asignación de valores de un tipo de datos a valores de otro tipo. La capacidad de usar colecciones de forma eficaz te permite implementar funciones comunes de apps para Android, como desplazar listas, y solucionar una variedad de problemas de programación reales que involucran cantidades arbitrarias de datos.

En este codelab, se analiza el modo en que se trabaja con varios valores en tu código y se presenta una variedad de estructuras de datos, como arrays, listas, conjuntos y mapas.

Requisitos previos

• Tener conocimientos de programación orientada a objetos en Kotlin, incluidas las clases, las interfaces y los elementos genéricos

Qué aprenderás

• Cómo crear y modificar arrays
• Cómo usar List y MutableList
• Cómo usar Set y MutableSet
• Cómo usar Map y MutableMap

Requisitos

• Un navegador web con acceso a Playground de Kotlin

2. Arrays en Kotlin

¿Qué es un array?

Un array es la forma más sencilla de agrupar un número arbitrario de valores en tus programas.

Al igual que una agrupación de paneles solares se denomina array solar, o del mismo modo en que aprender sobre Kotlin abre un conjunto (array) de posibilidades para tu carrera de programación, un Array representa más de un valor. Específicamente, un array es una secuencia de valores que tienen el mismo tipo de datos.

• Un array contiene varios valores llamados elementos o, a veces, objetos.
• Los elementos de un array se ordenan con un índice y se accede a ellos a través de él.

¿Qué es un índice? Un índice es un número entero que corresponde a un elemento del array. Indica la distancia de un elemento desde el elemento inicial de un array. Esto se denomina indexación cero. El primer elemento del array está en el índice 0, el segundo está en el índice 1, porque se encuentra a un lugar de distancia desde el primer elemento, y así sucesivamente.

En la memoria del dispositivo, los elementos del array se almacenan uno junto al otro. Si bien los detalles subyacentes están fuera del alcance de este codelab, esto tiene dos implicaciones importantes:

• Si usas su índice, puedes acceder a un elemento de array rápidamente. Puedes acceder a cualquier elemento aleatorio de un array desde su índice y esperar que demore la misma cantidad de tiempo para acceder a cualquier otro elemento aleatorio. Por eso se dice que los arrays tienen acceso aleatorio.
• Un array tiene un tamaño fijo. Esto significa que no puedes agregar elementos a un array que supere este tamaño. Si intentas acceder al elemento en el índice 100 de un array de 100 elementos, se arrojará una excepción porque el índice más alto es 99 (recuerda que el primer índice es 0, no 1). Sin embargo, puedes modificar los valores de los índices del array.

Nota: En este codelab, el término "memoria" hace referencia a la memoria de acceso aleatorio (RAM) del dispositivo a corto plazo, no al almacenamiento persistente a largo plazo. Se denomina "Acceso aleatorio" porque permite el acceso rápido a cualquier ubicación arbitraria en la memoria.

Para declarar un array en el código, usa la función arrayOf().

La función arrayOf() toma los elementos del array como parámetros y muestra un array del tipo que coincide con los parámetros que se pasaron. Esto puede verse un poco diferente a otras funciones que hayas visto, ya que arrayOf() tiene una cantidad variable de parámetros. Si pasas dos argumentos a arrayOf(), el array resultante contiene dos elementos, 0 y 1 indexados. Si pasas tres argumentos, el array resultante tendrá 3 elementos, del 0 al 2 indexados.

Veamos los arrays en acción con una pequeña exploración del sistema solar.

1. Ve al Playground de Kotlin.
2. En main(), crea una variable rockPlanets. Llama a arrayOf() pasando el tipo String, junto con cuatro strings (una para cada uno de los planetas rocosos del sistema solar).

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

3. Debido a que Kotlin usa la inferencia de tipos, puedes omitir el nombre del tipo cuando llamas a arrayOf(). Debajo de la variable rockPlanets, agrega otra variable gasPlanets, sin pasar un tipo entre los corchetes angulares.

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

4. Puedes hacer grandes cosas con los arrays. Por ejemplo, al igual que los tipos numéricos Int o Double, puedes agregar dos arrays juntos. Crea una variable nueva llamada solarSystem y configúrala para que sea igual al resultado de rockPlanets y gasPlanets, con el operador más (+). El resultado es un array nuevo que contiene todos los elementos del array rockPlanets y los elementos del array gasPlanets.

val solarSystem = rockPlanets + gasPlanets

5. Ejecuta el programa para verificar que funcione. Todavía no deberías ver ningún resultado.

Cómo acceder a un elemento en un array

Puedes acceder a un elemento de un array con su índice.

Esto se llama sintaxis de subíndice. Consta de tres partes:

• El nombre del array
• Un corchete angular de apertura ([) y uno de cierre (])
• El índice del elemento de array entre corchetes

Vamos a acceder a los elementos del array de solarSystem con sus índices.

1. En main(), accede a cada elemento del array solarSystem para mostrarlo. Observa que el primer índice es 0 y el último es 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. Ejecuta el programa. Los elementos están en el mismo orden en que los enumeraste cuando llamaste a arrayOf().

Mercury
Venus
Earth
Mars
Jupiter
Saturn
Uranus
Neptune

También puedes definir el valor de un elemento de array por su índice.

El acceso al índice es igual que antes, es decir, el nombre del array, seguido de un corchete angular de apertura y cierre que contiene el índice. Luego, sigue el operador de asignación (=) y un valor nuevo.

Practiquemos la modificación de valores en el array solarSystem.

1. Le daremos un nuevo nombre a Marte para los futuros colonos humanos. Accede al elemento en el índice 3 y establécelo en "Little Earth".

solarSystem[3] = "Little Earth"

2. Muestra el elemento en el índice 3.

println(solarSystem[3])

3. Ejecuta el programa. Se actualiza el cuarto elemento del array (en el índice 3).

...
Little Earth

4. Ahora, supongamos que los científicos descubrieron que hay un noveno planeta más allá de Neptuno, llamado Plutón. Anteriormente, dijimos que no puedes cambiar el tamaño de un array. ¿Qué sucedería si lo intentaras? Intentemos agregar Plutón al array solarSystem. Agrega Plutón en el índice 8, ya que este es el noveno elemento del array.

solarSystem[8] = "Pluto"

5. Ejecuta tu código. Arroja una excepción ArrayIndexOutOfBounds. Debido a que el array ya tenía ocho elementos, como era de esperar, no puedes simplemente agregar un noveno elemento.

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

6. Quita Plutón del array.

Código para quitar

solarSystem[8] = "Pluto"

7. Si deseas hacer que un array sea más grande de lo que ya es, debes crear uno nuevo. Define una variable nueva llamada newSolarSystem, como se muestra. Este array puede almacenar nueve elementos, en lugar de ocho.

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

8. Ahora intenta mostrar el elemento en el índice 8.

println(newSolarSystem[8])

9. Ejecuta tu código y procura que se ejecute sin excepciones.

...
Pluto

Bien hecho. Con tu conocimiento sobre arrays, puedes hacer casi todo lo que quieras con las colecciones.

Espera, ¡no tan rápido! Si bien los arrays son uno de los aspectos fundamentales de la programación, usar uno para las tareas que requieren agregar y quitar elementos, singularidad en una colección o asignar objetos a otros objetos no es una tarea simple o sencilla, y el código de tu app podría desordenarse con rapidez.

Es por eso que la mayoría de los lenguajes de programación, incluido Kotlin, implementan tipos de colecciones especiales para controlar situaciones que comúnmente ocurren en apps reales. En las siguientes secciones, aprenderás sobre tres colecciones comunes: List, Set y Map. También aprenderás acerca de las propiedades y los métodos comunes, y las situaciones en las que se usan estos tipos de colecciones.

3. Listas

Una lista es una colección redimensionable y ordenada que, por lo general, se implementa como un array que puede cambiar de tamaño. Cuando el array alcanza su capacidad máxima y tratas de insertar un nuevo elemento, el array se copia en un nuevo array más grande.

Con una lista, también puedes insertar elementos nuevos entre otros elementos de un índice específico.

Así es como las listas pueden agregar y quitar elementos. En la mayoría de los casos, se necesita el mismo tiempo para agregar cualquier elemento a una lista, independientemente de la cantidad de elementos que haya en la lista. De vez en cuando, si cuando se agrega un elemento nuevo, el array supera su tamaño definido, es posible que los elementos del array deban moverse para liberar espacio para los elementos nuevos. Las listas hacen todo esto por ti, aunque en realidad, solo se trata de un array que se reemplaza por otro nuevo cuando es necesario.

List y MutableList

Los tipos de colección que encontrarás en Kotlin implementan una o más interfaces. Como viste en el codelab sobre elementos genéricos, objetos y extensiones que mencionamos antes en esta unidad, las interfaces proporcionan un conjunto estándar de propiedades y métodos para que una clase lo implemente. Una clase que implementa la interfaz List brinda implementaciones para todas las propiedades y los métodos de la interfaz List. Lo mismo sucede con MutableList.

¿Qué hacen List y MutableList?

• List es una interfaz que define las propiedades y los métodos relacionados con una colección ordenada de solo lectura de los elementos.
• MutableList extiende la interfaz List con la definición de métodos para modificar una lista, como agregar o quitar elementos.

Estas interfaces solo especifican las propiedades y los métodos de List o MutableList. A la clase que las extiende le corresponde determinar el uso de cada propiedad y método. Aunque Kotlin permite que otras clases extiendan List y MutableList, la implementación basada en arrays descrita anteriormente es la que usarás con mayor frecuencia (o quizás todo el tiempo).

La función listOf()

Al igual que arrayOf(), la función listOf() toma los elementos como parámetros, pero muestra un elemento List en lugar de un array.

1. Quita el código existente de main().
2. En main(), llama a listOf() para crear un elemento List de planetas llamado solarSystem.

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

3. List tiene una propiedad size para obtener la cantidad de elementos de la lista. Muestra el size de la lista solarSystem.

println(solarSystem.size)

4. Ejecuta tu código. El tamaño de la lista debe ser de 8.

8

Cómo acceder a los elementos desde una lista

Al igual que un array, puedes acceder a un elemento en un índice específico desde un elemento List con la sintaxis de subíndice. Puedes hacer lo mismo si usas el método get(). La sintaxis de subíndice y el método get() toman un elemento Int como parámetro y muestran el elemento en ese índice. Al igual que Array, ArrayList está indexado por cero; por ejemplo, el cuarto elemento estaría en el índice 3.

1. Muestra el planeta en el índice 2 con la sintaxis de subíndice.

println(solarSystem[2])

2. Para mostrar el elemento en el índice 3, llama a get() en la lista solarSystem.

println(solarSystem.get(3))

3. Ejecuta tu código. El elemento en el índice 2 es "Earth" y el elemento en el índice 3 es "Mars".

...
Earth
Mars

Además de obtener un elemento a través de su índice, puedes buscar el índice de un elemento específico con el método indexOf(). El método indexOf() busca en la lista un elemento determinado (pasado como un argumento) y muestra el índice de la primera instancia de ese elemento. Si el elemento no aparece en la lista, se muestra -1.

1. Muestra el resultado de la llamada a indexOf() en la lista solarSystem y pasa "Earth".

println(solarSystem.indexOf("Earth"))

2. Llama a indexOf(), pasa "Pluto" y, luego, muestra el resultado.

println(solarSystem.indexOf("Pluto"))

3. Ejecuta tu código. Un elemento coincide con "Earth", por lo que se muestra el índice 2. No hay ningún elemento que coincida con "Pluto", por lo que se muestra -1.

...
2
-1

Cómo iterar en elementos de lista con un bucle for

Cuando aprendiste sobre los tipos de funciones y las expresiones lambda, viste el modo en que podías usar la función repeat() para ejecutar código varias veces.

Una tarea común en la programación es realizar una tarea una vez por cada elemento de una lista. Kotlin incluye una función llamada bucle for para lograr esto con una sintaxis concisa y legible. A menudo, verás que esto se conoce como bucle a través de una lista o iteración sobre una lista.

Para realizar un bucle a lo largo de una lista, usa la palabra clave for, seguida de un par de paréntesis de apertura y cierre. Dentro de los paréntesis, incluye un nombre de variable, seguido de la palabra clave in y del nombre de la colección. Después del paréntesis de cierre, sigue un par de llaves de apertura y cierre, en las que debes incluir el código que deseas ejecutar para cada elemento de la colección. Esto se conoce como el cuerpo del bucle. Cada vez que se ejecuta este código, se conoce como iteración.

La variable antes de que la palabra clave in no está declarada con val ni var, por lo que se asume que es de solo acceso. Puedes asignarle el nombre que desees. Si una lista recibe un nombre en plural, como planets, es común nombrar a la variable con el formato en singular, como planet. También es común asignar el nombre item o element a la variable.

Se usará como una variable temporal correspondiente al elemento actual de la colección (el elemento del índice 0 para la primera iteración, el elemento del índice 1 para la segunda iteración, etc.) y se puede acceder a ella desde las llaves.

Para ver esto en acción, debes mostrar el nombre de cada planeta en una línea separada con un bucle for.

1. En main(), debajo de la llamada más reciente a println(), agrega un bucle for. Dentro de los paréntesis, asigna un nombre a la variable planet y realiza un bucle a lo largo de la lista solarSystem.

for (planet in solarSystem) {
}

2. Dentro de llaves, muestra el valor de planet con println().

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

3. Ejecuta tu código. El código dentro del cuerpo del bucle se ejecuta para cada elemento de la colección.

...
Mercury
Venus
Earth
Mars
Jupiter
Saturn
Uranus
Neptune

Cómo agregar elementos a una lista

La capacidad de agregar, quitar y actualizar elementos de una colección es exclusiva de las clases que implementan la interfaz MutableList. Si estás haciendo un seguimiento de los planetas que se descubrieron hace poco, es probable que quieras agregar con frecuencia elementos a una lista. Cuando creas una lista en la que deseas agregar o quitar elementos, debes llamar específicamente a la función mutableListOf(), en lugar de a listOf().

Hay dos versiones de la función add():

• La primera función add() tiene un solo parámetro del tipo de elemento de la lista y lo agrega al final de la lista.
• La otra versión de add() tiene dos parámetros. El primer parámetro corresponde a un índice en el que se debe insertar el nuevo elemento. El segundo parámetro es el elemento que se agrega a la lista.

Veamos esto en acción.

1. Cambia la inicialización de solarSystem para llamar a mutableListOf() en lugar de listOf(). Ahora puedes llamar a métodos definidos en MutableList.

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

2. Una vez más, quizás quieras clasificar a Plutón como un planeta. Llama al método add() en solarSystem y pasa "Pluto" como el único argumento.

solarSystem.add("Pluto")

3. Algunos científicos sostienen la teoría de que hubo un planeta llamado Tea, que luego chocó con la Tierra y formó la Luna. Inserta "Theia" en el índice 3, entre "Earth" y "Mars".

solarSystem.add(3, "Theia")

Cómo actualizar elementos en un índice específico

Puedes actualizar elementos existentes con sintaxis de subíndice:

1. Actualiza el valor del índice 3 a "Future Moon".

solarSystem[3] = "Future Moon"

2. Muestra el valor de los índices 3 y 9 con la sintaxis de subíndice.

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

3. Ejecuta tu código para verificar el resultado.

Future Moon
Pluto

Cómo quitar elementos de una lista

Los elementos se quitan con el método remove() o removeAt(). Para quitar un elemento, puedes pasarlo al método remove() o utilizar su índice mediante removeAt().

Veamos ambos métodos para quitar un elemento en acción.

1. Llama a removeAt() en solarSystem y pasa 9 para el índice. Se debería quitar "Pluto" de la lista.

solarSystem.removeAt(9)

2. Llama a remove() en solarSystem y pasa "Future Moon" como el elemento que quieres quitar. Esta acción debería buscar en la lista y, si se encuentra un elemento coincidente, se lo quitará.

solarSystem.remove("Future Moon")

3. List proporciona el método contains() que muestra un Boolean si existe un elemento en una lista. Muestra el resultado de la llamada a contains() para "Pluto".

println(solarSystem.contains("Pluto"))

4. Una sintaxis aún más concisa consiste en usar el operador in. Puedes verificar si un elemento está en una lista utilizando el elemento, el operador in y la colección. Usa el operador in para verificar si solarSystem contiene "Future Moon".

println("Future Moon" in solarSystem)

5. Ejecuta tu código. Ambas sentencias deben mostrar false.

...
false
false

4. Conjuntos

Un conjunto es una colección que no tiene un orden específico y no permite valores duplicados.

¿Por qué es posible crear una colección como esta? El secreto es un código hash. Un código hash es un Int que produce el método hashCode() de cualquier clase de Kotlin. Se puede interpretar como un identificador semiúnico de un objeto de Kotlin. Un pequeño cambio en el objeto, como agregar un carácter a la String, da como resultado un valor de hash muy diferente. Si bien es posible que dos objetos tengan el mismo código hash (llamado colisión de hash), la función hashCode() garantiza cierto grado de exclusividad. En la mayoría de los casos, dos valores diferentes tienen un código hash único.

Nota: Un conjunto usa códigos hash como índices de array. Por supuesto, puede haber alrededor de 4,000 millones de códigos hash diferentes, por lo que un Set no es solo un array gigante. En cambio, piensa que un Set es como un array de listas.

El array externo (los números en azul a la izquierda) corresponde a un rango (también conocido como bucket) de posibles códigos hash. Cada lista interna, sombreada de verde en el lado derecho, representa los elementos individuales del conjunto. Debido a que las colisiones de hash son relativamente poco comunes, incluso cuando los índices potenciales son limitados, las listas internas de cada índice de array solo tendrán uno o dos elementos cada una, a menos que se agreguen decenas o cientos de miles de elementos.

Los conjuntos tienen las siguientes dos propiedades importantes:

1. La búsqueda de un elemento específico en un conjunto es rápido, en comparación con las listas, especialmente para las colecciones grandes. Si bien el indexOf() de una List requiere que se verifique cada elemento desde el principio hasta que se encuentre una coincidencia, en promedio, se necesita la misma cantidad de tiempo para verificar si un elemento está en un conjunto, ya sea el primer elemento o el número cien mil.
2. Los conjuntos suelen usar más memoria que las listas para la misma cantidad de datos, ya que a menudo se necesitan más índices de array que los datos del conjunto.

Nota: Contrario a lo que se cree, el tiempo que lleva verificar si un conjunto contiene un elemento no es fijo y, de hecho, depende de la cantidad de datos del conjunto. Sin embargo, como suele haber pocas colisiones de hash, la cantidad de elementos que deben verificarse sigue siendo órdenes de magnitud más pequeña que la búsqueda de un elemento en una lista.

El beneficio de los conjuntos es garantizar la singularidad. Si estuvieras escribiendo un programa para hacer un seguimiento de los planetas recién descubiertos, un conjunto ofrecería una manera simple de comprobar si un planeta ya fue descubierto. Cuando hay grandes cantidades de datos, esto suele ser preferible a verificar si un elemento existe en una lista, lo que requiere la iteración de todos los elementos.

Al igual que List y MutableList, hay un Set y un MutableSet. MutableSet implementa Set, por lo que cualquier clase que implemente MutableSet debe usar ambos elementos.

Cómo usar un MutableSet en Kotlin

En el ejemplo, usaremos un elemento MutableSet para demostrar cómo agregar y quitar elementos.

1. Quita el código existente de main().
2. Crea un Set de planetas llamado solarSystem con mutableSetOf(). Esto muestra un MutableSet, cuya implementación predeterminada es LinkedHashSet().

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

3. Muestra el tamaño del conjunto con la propiedad size.

println(solarSystem.size)

4. Al igual que List, Set tiene un método add(). Agrega "Pluto" al conjunto solarSystem con el método add(). Solo se necesita un parámetro para el elemento que se agrega. Los elementos de los conjuntos no tienen necesariamente un orden, por lo que no hay índice.

solarSystem.add("Pluto")

5. Muestra el size del conjunto después de agregar el elemento.

println(solarSystem.size)

6. La función contains() toma un solo parámetro y comprueba si el elemento especificado está incluido en el conjunto. De ser así, el resultado será verdadero. De lo contrario, el resultado es falso. Llama a contains() para comprobar si "Pluto" está en solarSystem.

println(solarSystem.contains("Pluto"))

7. Ejecuta tu código. El tamaño aumentó y contains() ahora muestra true.

8
9
true

Nota: También puedes usar el operador in para verificar si un elemento está en una colección. Por ejemplo: "Pluto" in solarSystem es equivalente a solarSystem.contains("Pluto").

8. Como se mencionó antes, los conjuntos no pueden contener duplicados. Intenta agregar de nuevo "Pluto".

solarSystem.add("Pluto")

9. Vuelve a mostrar el tamaño del conjunto.

println(solarSystem.size)

10. Vuelve a ejecutar tu código. No se agregó "Pluto" porque ya está en el conjunto. Esta vez, el tamaño no debería aumentar.

...
9

La función remove() toma un solo parámetro y quita el elemento especificado del conjunto.

1. Usa la función remove() para quitar "Pluto".

solarSystem.remove("Pluto")

Nota: Recuerda que los conjuntos son una colección sin ordenar. No hay forma de quitar un valor de un conjunto según su índice, ya que los conjuntos no tienen índices.

2. Muestra el tamaño de la colección y vuelve a llamar a contains() para comprobar si "Pluto" todavía está en el conjunto.

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

3. Ejecuta tu código. "Pluto" ya no está en el conjunto. El tamaño ahora es 8.

...
8
false

5. Colección de mapas

Un Map es una colección que consta de claves y valores. Se llama un mapa porque las claves únicas se asignan a otros valores. Una clave y su valor complementario suelen llamarse key-value pair.

Las claves de un mapa son únicas. Sin embargo, los valores de un mapa no lo son. Dos claves diferentes podrían mapear al mismo valor. Por ejemplo, "Mercury" tiene 0 lunas, y "Venus" tiene 0 lunas.

Acceder a un valor desde un mapa por su clave suele ser más rápido que realizar una búsqueda en una lista grande, como con indexOf().

Los mapas se pueden declarar con las funciones mapOf() o mutableMapOf(). Los mapas requieren dos tipos genéricos separados por comas: uno para las claves y otro para los valores.

Un mapa también puede usar la inferencia de tipo si tiene valores iniciales. Para propagar un mapa con valores iniciales, cada par clave-valor consta de la clave, seguida del operador to y del valor. Cada par está separado por una coma.

Veamos con más detalle el uso de los mapas y algunas propiedades y métodos útiles.

1. Quita el código existente de main().
2. Crea un mapa llamado solarSystem con mutableMapOf() con valores iniciales, como se muestra.

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. Al igual que las listas y los conjuntos, Map brinda una propiedad size, que contiene la cantidad de pares clave-valor. Muestra el tamaño del mapa de solarSystem.

println(solarSystem.size)

4. Puedes usar la sintaxis de subíndice para configurar pares clave-valor adicionales. Establece la clave "Pluto" en un valor de 5.

solarSystem["Pluto"] = 5

5. Después de insertar el elemento, vuelve a mostrar el tamaño.

println(solarSystem.size)

6. Puedes usar la sintaxis de subíndice para obtener un valor. Muestra el número de lunas de la clave "Pluto".

println(solarSystem["Pluto"])

7. También puedes acceder a valores con el método get(). Ya sea que uses sintaxis de subíndice o llames a get(), es posible que la clave que pases no esté en el mapa. Si no hay un par clave-valor, se mostrará un valor nulo. Muestra la cantidad de lunas de "Theia".

println(solarSystem["Theia"])

8. Ejecuta tu código. Debería mostrarse la cantidad de lunas de Plutón. Sin embargo, dado que Tea no está en el mapa, la llamada a get() tiene un valor nulo.

8
9
5
null

El método remove() quita el par clave-valor con la clave especificada. También muestra el valor que se quitó, o null, si la clave especificada no está en el mapa.

1. Muestra el resultado de la llamada a remove() y pasa "Pluto".

solarSystem.remove("Pluto")

2. Para verificar que el elemento se haya quitado, vuelve a mostrar el tamaño.

println(solarSystem.size)

3. Ejecuta tu código. El tamaño del mapa es 8 después de quitar la entrada.

...
8

4. La sintaxis de subíndice, o el método put(), también puede modificar el valor de una clave que ya existe. Usa la sintaxis de subíndice para actualizar las lunas de Júpiter a 78 y muestra el nuevo valor.

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

5. Ejecuta tu código. Se actualiza el valor de la clave existente, "Jupiter".

...
78

6. Conclusión

¡Felicitaciones! Aprendiste sobre uno de los tipos de datos más fundamentales en la programación, el array y varios tipos de colecciones convenientes creados a partir de arrays, como List, Set y Map. Estos tipos de colecciones te permiten agrupar y organizar valores en tu código. Los arrays y las listas proporcionan acceso rápido a los elementos según su índice, mientras que los conjuntos y mapas usan códigos hash para que sea más fácil encontrar elementos en la colección. Verás que estos tipos de colecciones se utilizarán con frecuencia en apps futuras, y saber sobre su uso te beneficiará en tu futura carrera de programación.

Resumen

• Los arrays almacenan datos ordenados del mismo tipo y tienen un tamaño fijo.
• Los arrays se usan para implementar muchos de los otros tipos de colecciones.
• Las listas son una colección ordenada y de tamaño variable.
• Los conjuntos son colecciones sin ordenar y no pueden contener duplicados.
• Los mapas funcionan de manera similar a los conjuntos y almacenan pares de claves y valores del tipo especificado.

7. Más información

• Colecciones
• Lista
• Condiciones y bucles
• MutableList
• Conjunto
• hashCode()
• MutableSet
• Mapa
• MutableMap