Tema 8. Arrays en Kotlin

Explicación del funcionamiento de los Arrays y sus características diferenciadoras.

La información básica de los Arrays se encuentra en el tema 2.

un Array representa más de un valor. Específicamente, un array es una secuencia de valores que tienen el mismo tipo de datos e identificados por un nombre común.

En la memoria del dispositivo, los elementos del array se almacenan uno junto al otro.

Además el Array tiene un tamaño fijo.

CREAR ARRAYS

Existen tres funciones que se pueden utilizar para crear datos de tipo Array:

• arrayOf(elementos: T) -> De esta manera podemos declarar un Array con sus elementos ya definidos:

var diasDeSemana: Array<String> = arrayOf(
    "lunes", "martes", "miercoles", "jueves", "viernes"
)

• arrayOfNulls(tamaño: Int) -> De esta manera se puede generar fácilmente un Array con un tamaño definido pero con datos de tipo Null en su interior, a la espera de modificarlo más adelante:

var sueldosMensuales: Array<Int> = arrayOfNulls(12) 

• emptyArray() -> Con esta función se genera fácilmente un Array vacío. Cuidado al generar Arrays vacíos ya que no se puede añadir datos en ellos.

var vacio = emptyArray<String>()

Para generar Arrays vacíos es obligatorio dar un tipo de datos a los elementos del Array aunque estos no existan.

UTILIZAR EL CONSTRUCTOR

Hay situaciones en las que queremos que los datos contenidos en un Array surjan de la ejecución de una función. En estos casos utilizamos el método constructor de la clase Array:

Array(tamaño: Int) { sentencia }

// Un array con los números negativos del -1 al -10.
val negativeNumbers = Array(10) { -(it + 1) }

Esto puede ser útil también en las colecciones que se ven a continuación. Cada una de ellas tiene un método constructor de la misma manera que tienen los Arrays que se puede utilizar para lo mismo.

ARRAYS MULTIDIMENSIONALES

Los arrays son equivalentes a vectores en matemáticas. Sin embargo, en Matemáticas se pueden crear vectores de vectores, lo que nos da una Matriz.

En Kotlin, igual que en matemáticas, se pueden crear Arrays de Arrays para representar matrices. Lo único que hay que hacer es anidar los Arrays.

val matriz: Array<Array<Int>> = arrayOf(
    arrayOf(1, 2, 3),
    arrayOf(4, 5, 6),
    arrayOf(7, 8, 9)
)

De la misma manera que se crean Arrays multidimensionales podemos crear Listas Multidimensionales con la característica de que se puede modificar la cantidad de elementos.

FUNCIONES Y MÉTODOS

Acceso a elementos

La forma más sencilla de acceder a elementos es utilizando los corchetes con un índice "[n]".

También se puede acceder a elementos utilizando la función get(n).

var numeros = arrayOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
// Indices:           0  1  2  3  4  5  6  7  8  9

println(numeros[5])     // 6
println(numeros.get(5)) // 6

Modificación de elementos

Los elementos dentro de un Array se pueden modificar, no así su cantidad. Para ello podemos utilizar el operador "=" o la función set(n, valor)

val vector = arrayOf(1, 2, 3, 4)
vector[0] = 10        // 10, 2, 3, 4
vector.set(3, 15)     // 10, 2, 3, 15

Métodos

Los métodos son conjuntos de instrucciones definidas dentro de una clase, que realizan una determinada tarea y a las que podemos invocar mediante un nombre.

En el caso de los Arrays, existen tres métodos que pueden ser útiles a a la hora de recorrer el array por ejemplo:

• array.size -> Devuelve la cantidad de elementos que tiene el Array.

• array.lastIndex -> Devuelve el último índice del Array.

• array.indices -> Devuelve los índices del Array en la forma 0..lastIndex

val vector = arrayOf(1, 2, 3, 4)

println(vector.size)        // 4
println(vector.indices)     // 0..3
println(vector.lastIndex)   // 3

Funciones

Array - Kotlin Programming LanguageKotlin

Fuente: kotlinlang.org

RECORRER ARRAYS

Uno de los usos típicos de los Arrays es recorrer sus elementos. Para ello utilizamos un bucle for y uno de los métodos que hemos visto anteriormente:

val vector = arrayOf(1, 2, 3, 4)
for (i in vector) println(i)
for (i in 0..vector.size - 1) println(vector[i])
for (i in 0..vector.lastIndex) println(vector[i])
for (i in vector.indices) println(vector[i])

println(vector.size)        // 4
println(vector.indices)     // 0..3
println(vector.lastIndex)   // 3

Recorrer Arrays multidimensionales

Puede darse el caso en el que queramos recorrer todos los elementos de un Array multidimensional, ya sea para tratarlos o para pintarlos. Para ello se utilizan bucles for anidados:

val matriz: Array<Array<Int>> = arrayOf(
    arrayOf(1, 2, 3),
    arrayOf(4, 5, 6),
    arrayOf(7, 8, 9)
)
for (i in matriz.indices) {
    for (j in matriz[i].indices) print("${matriz[i][j]} ")
    println()
}

/* Resultado
1 2 3 
4 5 6 
7 8 9
*/

INDICAR TIPO DE ELEMENTOS

En los casos donde se quiera indicar manualmente el tipo de los elementos que forman parte del Array, esto no se puede hacer con la función arrayOf(). Para ello se desarrollaron las siguientes funciones:

• booleanArrayOf(): para crear Arrays de tipo boolean.

• intArrayOf(): para crear Arrays de tipo integer.

• shortArrayOf(): para crear Arrays de tipo Short.

• longArrayOf(): para crear Arrays de tipo long.

• floatArrayOf(): para crear Arrays de tipo float.

• doubleArrayOf(): para crear Arrays de tipo double.

• byteArrayOf(): para crear Arrays de tipo byte.

• charArrayOf(): para crear Arrays de tipo char.