Manejo de listas¶

Hacer listas para todo tipo de situaciones de la vida cotidiana es algo habitual. Por ejemplo, en una app, podría haber una lista de artículos de noticias, de canciones, de eventos del calendario o de publicaciones en redes sociales. De ahora en adelante nos centraremos en la implementación de las mismas en Kotlin.

Listas¶

Una lista es una colección de elementos con un orden específico. Hay dos tipos de listas en Kotlin:

Lista de solo lectura: List no se puede modificar después de su creación.
Lista mutable: MutableList se puede modificar después de su creación, lo que significa que puedes agregar, quitar o actualizar sus elementos.

Cuando usas List o MutableList, debes especificar el tipo de elemento que pueden contener.

Ejemplos de uso

List<Int> contiene una lista de números enteros y List<String> contiene una lista de Strings. Si defines una clase Car en tu programa, puedes tener una List<Car> que contenga una lista de instancias de objetos Car.

Veamos esto sobre un ejemplo que nos ayudará a entender la manera en la que funcionan las listas:

fun main() {

    val numbers: List<Int> = listOf(1, 2, 3, 4, 5, 6)

    /* Si el tipo de variable se puede adivinar (o inferir) en
    * función del valor a la derecha del operador de asignación (=),
    * puedes omitir el tipo de datos de la variable.*/

    println("List: $numbers")

    /*Recuerda que colocar $ en la string significa que
    * lo que sigue es una expresión que se evaluará y se agregará a esta
    * string (consulta las plantillas de strings).
    * Esta línea de código también se puede escribir como
    * println("List: " + numbers).*/

    println("Size: ${numbers.size}")
}

Accediendo a los elementos de una lista¶

La funcionalidad específica de las listas es que puedes acceder a cada elemento de ellas mediante su índice, que es un número entero que representa la posición. Este es un diagrama de la lista numbers que creamos, donde se muestra cada elemento y su correspondiente índice.

Info

Por ejemplo, cuando indicas list[2], no solicitas el segundo elemento de la lista, sino el elemento que está desplazado 2 posiciones respecto del primer elemento. Por lo tanto, list[0] es el primer elemento (ningún desplazamiento), list[1] es el segundo (desplazamiento de 1), list[2] es el tercero (desplazamiento de 2), y así sucesivamente.

Si queremos ver un ejemplo de la manera en la Kotlin trabaja el acceso a las listas, lo veremos sobre el siguiente código:

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5, 6)
    println("Lista: $numbers")
    println("Tamaño: ${numbers.size}")

    // Acceder a los elementos de la lista
    println("Primer elemento: ${numbers[0]}")
    println("Segundo elemento: ${numbers[1]}")
    println("Último índice: ${numbers.size - 1}")
    println("Último elemento: ${numbers[numbers.size - 1]}")
    println("Primero: ${numbers.first()}")
    println("Último: ${numbers.last()}")

    // Usar el método contains()
    println("¿Contiene el 4? ${numbers.contains(4)}")
    println("¿Contiene el 7? ${numbers.contains(7)}")
}

Vemos funciones que no necesitan explicación, como first(), last() o contains(). Estas funciones nos ayudarán a trabajar de una manera más óptima con las listas.

Listas de sólo lectura¶

En estas listas no es posible cambiar los elementos que la forman. Sin embargo, existen varias operaciones de listas que no las cambian, sino que muestran una nueva. Dos de ellas son reversed() y sorted(). La función reversed() muestra una lista nueva en la que los elementos se encuentran en orden inverso, y sorted() muestra otra en la que los elementos están ordenados en forma ascendente.

Listas mutables¶

Las listas mutables son listas que pueden modificarse luego de su creación. Puedes agregar, quitar o cambiar elementos. También podrás hacer todo aquello que puedes hacer con las listas de solo lectura. Las listas mutables son de tipo MutableList, y puedes crearlas llamando a mutableListOf().

Cuando se crea una MutableList o una List, Kotlin intenta determinar qué tipo de elementos contiene la lista a partir de los argumentos pasados.

Por ejemplo, si escribes listOf("noodles"), Kotlin determina que quieres crear una lista de String. Cuando inicializas una lista vacía sin elementos, Kotlin no puede determinar el tipo de elementos, por lo que deberás indicar ese tipo de forma explícita.

Para ello, agrega el tipo entre corchetes angulares justo después de mutableListOf o listOf

fun main() {
    val entrees = mutableListOf<String>()

    /*Otra forma de corregir es especificar el tipo de datos
    * de la variable por adelantado.
    * val entrees: MutableList<String> = mutableListOf()*/

    println("Entrees: $entrees")
}

Para añadir un elemento a la lista usaremos la función add(). La función add() muestra true si el elemento se agregó correctamente a la lista. De lo contrario, muestra false. En lugar de agregar elementos uno por uno con add(), puedes agregar varios elementos a la vez usando addAll() y pasando una lista.

Recuerda que...

cuando agregas elementos a una lista, estos deben ser del tipo de datos correcto. De lo contrario, se mostrará un error de compilación. De esta manera, Kotlin garantiza que tu código resulte más seguro mediante la seguridad de tipo.

Para eliminar un elemento de la lista usaremos la función remove(). Esta funciona como add(), si tiene éxito muestra true, de lo contrario false. También se puede especificar el índice del elemento que deseas quitar. Para ello se usará removeAt() a fin de quitar el elemento del índice que se desee. Si lo que se desea es borrar la lista completa, puedes llamar a clear().

¿Cómo se si una lista está vacía?

Kotlin te permite verificar si una lista está vacía mediante la función isEmpty(). El método isEmpty() resulta útil si deseas realizar una operación en una lista o acceder a un elemento determinado, pero primero asegúrate de que la lista no esté vacía.

Veamos todo esto con un ejemplo en código:

class="linenos" data-linenos=" 1 ">fun main() { val entrees = mutableListOf<String>() println("Entrantes: $entrees") // Agregar elementos individuales usando add() println("Agregar fideos: ${entrees.add("fideos")}") println("Entrantes: $entrees") println("Agregar espaguetis: ${entrees.add("espaguetis")}") println("Entrantes: $entrees") // Agregar una lista de elementos usando addAll() val moreItems = listOf("ravioles", "lasaña", "fettuccine") println("Agregar lista: ${entrees.addAll(moreItems)}") println("Entrantes: $entrees") // Eliminar un elemento usando remove() println("Eliminar espaguetis: ${entrees.remove("espaguetis")}") println("Entrantes: $entrees") println("Eliminar elemento que no existe: ${entrees.remove("arroz")}") println("Entrantes: $entrees") // Eliminar un elemento usando removeAt() con un índice println("Eliminar primer elemento: ${entrees.removeAt(0)}") println("Entrantes: $entrees") // Vaciar la lista entrees.clear() println("Entrantes: $entrees") // Verificar si la lista está vacía println("¿Vacía? ${entrees.isEmpty()}") }

Listas y bucles¶

Se puede usar un bucle while para iterar a través de una lista. Crea una variable a fin de hacer un seguimiento del index que estás viendo en la lista. Esta variable index se incrementará en 1 cada vez hasta que llegues al último índice de la lista, después de lo cual saldrás del bucle.

val guestsPerFamily = listOf(2, 4, 1, 3)
var totalGuests = 0
var index = 0

// Mientras el índice sea menor que el tamaño de la lista
while (index < guestsPerFamily.size) {
    totalGuests += guestsPerFamily[index] // Sumar los invitados de cada familia
    index++ // Avanzar al siguiente índice
}

// Imprimir el total de invitados
println("Cantidad total de invitados: $totalGuests")

Otra manera de hacerlo, más óptima, es con un bucle for. Comienza con la palabra clave for en Kotlin y el bloque de código entre llaves. La condición para ejecutar ese bloque se indica entre paréntesis.

val names = listOf("Jessica", "Henry", "Alicia", "Jose")
for (name in names) {
    println("$name - Número de caracteres: ${name.length}")
}

Otras manera de escribir un for

A continuación, se muestran otras variantes de lo que puedes hacer con los bucles for, incluido su uso en rangos con pasos específicos (en lugar de aumentar en 1 con cada iteración).

for (item in list) print(item) // Iterate over items in a list
for (item in 'b'..'g') print(item) // Range of characters in an alphabet
for (item in 1..5) print(item) // Range of numbers
for (item in 5 downTo 1) print(item) // Going backward
for (item in 3..6 step 2) print(item) // Prints: 35

Un bucle es una estructura de flujo de control, como las expresiones if / else y when.

Actividades¶

AC 301 (RA2 / CE2a / IC1 / 1p). Diseña un programa que almacene las edades de varios participantes en una lista. El programa debe recorrer la lista y mostrar cuántos de ellos son mayores de edad (18 años o más).
AC 302 (RA2 / CE2a / IC1 / 1p). Crea un programa que guarde en una lista mutable los nombres de distintas frutas. Permite agregar nuevas frutas, eliminar una que ya no se desee y finalmente mostrar cuántas frutas quedan en la lista.
AC 303 (RA2 / CE2a / IC1 / 1p). Realiza un programa que almacene los puntajes obtenidos por un jugador en diferentes rondas. Estas puntuaciones se han de solicitar al usuario.

Calcula el puntaje total y, si supera los 50 puntos, muestra el mensaje "¡Has ganado!", de lo contrario muestra "Sigue intentando".