Los arrays y listas en Kotlin: Primeros pasos estas estructuras mutables e inmutables

11-07-2018 - Andrés Cruz

In english

Los arrays o arreglos y las listas son un elemento fundamental en cualquier lenguaje de programación que permiten manejar colecciones de valores o de datos de un mismo tipo ya sean entre las primitivas de Kotlin o nuestros propios objetos; en Kotlin.

Como principio fundamental en Kotlin, que es el manejo de los tipos mutables y los tipos inmutables, este principio también se extiende a los array y listas que veremos a continuación.

Los Arrays en Kotlin

Si queremos definir un array en Kotlin podemos hacerlo mediante los métodos arrayOf, arrayOfNULLs y emptyArray; cada una de estas formas comparten promiedades y funciones comunes como veremos un poco más adelante; finalmente, para crear un array con el método arrayOf tenemos:

var array = arrayOf(1,2,3,4,5)

Y con esto creamos un array de enteros; si queremos imprimir el array como un String o cadena de texto, en donde separaremos cada uno de los elementos que componen el array por comas podemos emplear el siguiente método:

array.joinToString()

Y obtenemos

1, 2, 3, 4, 5

Variaciones en los métodos arrayOf, arrayOfNULLs y arrayOfNULLs

Si queremos declarar el array anterior con enteros empleamos el método intArrayOf:

var array = intArrayOf(1,2,3,4,5)

Si por el contrario queremos que sean de double:

var array = doubleArrayOf(1.1,2.2,3.3,4.4,5.5)

Por supuesto, en todos los casos podemos emplear las mismas primitivas y métodos como el que mencionamos anteriormente que es el método joinToString ():

array.joinToString() //imprime 1.1, 2.2, 3.3, 4.4, 5.5

Para obtener el tamaño del array empleamos la propiedad size:

array.size // imprime 5 en cualquiera de los casos anteriores

También podemos emplear algunas funciones para obtener o establecer valores:

var array = doubleArrayOf(1.1,2.2,3.3,4.4,5.5)
println(array.get(2)) // imprime 3.3 

array.set(2, 2.5) // establecemos el valor 2.5 en el índice 2

println(array.get(2)) // imprime 2.5 

También podemos obtener valores como si un array se tratase:

println(array[2]) // imprime 2.5

Las listas en Kotlin

Como mencionamos en un inicio y como principio fundamental en Kotlin, tenemos el manejo de los tipos mutables y los tipos inmutables lo cual llevan también al uso de las listas, así que por defecto, las listas en Kotlin son inmutables, lo que en otras palabras significa, que no pueden mutar o lo que es lo mismo que no pueden cambiar, por lo tanto Kotlin provee métodos para consultas, por otra parte, para las listas inmutables Kotlin provee métodos para mutar las listas como queramos, es decir método como editar o cambiar valores o remover los mismos; primero veremos las listas por defecto o las de tipo inmutables:

Listas inmutables

Para crear una lista tenemos la clase List predefinida en Kotlin que permite crear listas de objetos genéricos; es decir, de cualquier tipo; para crear una lista de elementos inmutables tenemos:

val list = listOf(1,2,3,4,5)

Aquí NO se extiende una misma organización que se presenta con los Array que vimos anteriormente, y es que no podemos especificar el tipo de dato de la lista indicando el tipo de dato delante del nombre de la lista como hicimos con las Array; es decir, lo siguiente sería un código inválido:

val list = intListOf(1,2,3,4,5) // error: unresolved reference: intListOf

Listas Mutables

Si por el contrario necesitamos personalizar los valores de la lista, es decir emplear métodos para agregar, remover o cambiar valores, podemos emplear las listas mutables y de esta forma tenemos un abanico extra de opciones para poder personalizar o cambiar la lista cuando queramos; para ello debemos agregar "mutable" delante del "ListOf" por ejemplo, para crear una lista mutable tenemos:

val mutableList = mutableListOf(1,2,3,4,5 )

Para cambiar un valor, podemos hacerlo de dos formas, al igual que ocurre con los Array:

mutableList[1] = 85
println(mutableList[1]) // imprime 85

o mediante:

mutableList.set(1,90)
println(mutableList.get(1)) // imprime 90

En los dos bloques de código anterior además de cambiar o establecer otro valor a un índice de la lista, vimos como obtener el valor de la misma, para ello usamos el método convencional empleando los corchetes [] y entre ellos el índice o index de la posición que queremos consultar, o el método get que recibe como parámetro dicho índice, podemos emplear tanto para establecer cómo obtener valores el método que prefiramos.

Eliminar valores de la lista mediante valor e índice.

También tenemos métodos para eliminar los valores, para ello está el método removeAt que permite eliminar un valor de la lista indicando el índice de la posición que queremos eliminar y remove que permite eliminar un valor mediante el valor de la posición:

val mutableList = mutableListOf(10,20,30,400,50)

mutableList.removeAt(1)
// la lista queda mutableList [10, 30, 400, 50]

mutableList.remove(400)
// la lista queda mutableList [10, 30, 50]

Listas mutables e inmutables

Como podemos apreciar, de manera predefinida Kotlin ofrece listOf y con agregar la palabra "mutable" ya podemos manejar tipos mutables, es una especie de "regla" o tip que podemos tener en cuenta cuando trabajamos con listas; con los tipos mutables, que si lo llevamos a su significado base viene siendo aquellos que pueden mutar o cambiar podemos hacer métodos para obtener valores mediante get, eliminar mediante y establecer valores mediante set cosa que no podemos hacer con las listas mutables

También las listas cuentan con métodos y propiedades en común como la propiedad size:

val mutableList = mutableListOf(1,2,3,4,5 )
mutableList.size // imprime 5 

Listas SetOf

En adicional a las listas que vimos anteriormente, Kotlin también cuenta con otra estructura similar a de las listas que son las setOf que son colecciones de datos que no permiten tener valores repetidos, es decir solo permiten valores únicos es decir, que no se repitan:

val set = setOf(1,1,2,3,4,5,5,1)

Imprimirá:

[1, 2, 3, 4, 5]

Este tipo de colección de datos no permite modificar, eliminar o agregar nuevos valores, es decir, son de tipo inmutables; para modificarlo tenemos que emplear los tipos mutables.

val setMutable = mutableSetOf(1,2,3,4,5)

Andrés Cruz
Desarrollo con Laravel, Django, Flask, CodeIgniter, HTML5, CSS3, MySQL, JavaScript, Vue, Android, iOS, Flutter

Andrés Cruz en Udemy

Acepto recibir anuncios de interes sobre este Blog.

!Cursos a!

10$

En Udemy

Quedan 5 días!

Ver los cursos
¡Hazte afiliado en Gumroad!

!Cursos desde!

4$

En Academia

Ver los cursos

!Libros desde!

1$

Ver los libros
!Web Alojada en Hostinger!