Arrays¶

En programación, un array (o arreglo) permite almacenar varios valores del mismo tipo dentro de una única variable. En Kotlin, los arrays son objetos de primera clase, y existen versiones específicas para cada tipo primitivo.

Conceptos básicos¶

Hasta ahora hemos trabajado con variables simples: Int, Float, Double, Boolean, etc.
Sin embargo, cuando necesitamos manejar varios datos del mismo tipo —por ejemplo, las alturas de 5 personas—, es más eficiente usar un array.

La biblioteca estándar de Kotlin incluye las siguientes clases de arrays especializados:

Tipo de dato	Clase de array
Int	`IntArray`
Byte	`ByteArray`
Short	`ShortArray`
Long	`LongArray`
Float	`FloatArray`
Double	`DoubleArray`
Boolean	`BooleanArray`
Char	`CharArray`

Ejemplo

Definir un FloatArray de 5 elementos que contenga las alturas de 5 personas. Calcular el promedio y contar cuántas personas son más altas o más bajas que dicho promedio.

fun main() {
    val alturas = FloatArray(5)
    for (i in alturas.indices) {
        print("Introduce la altura ${i + 1}: ")
        alturas[i] = readln().toFloat()
    }

    val promedio = alturas.average().toFloat()

    var mayores = 0
    var menores = 0

    for (altura in alturas) {
        if (altura > promedio) mayores++ else if (altura < promedio) menores++
    }

    println("Promedio de alturas: $promedio")
    println("Personas más altas que el promedio: $mayores")
    println("Personas más bajas que el promedio: $menores")
}

Propiedad `indices`¶

Todas las clases de arrays (IntArray, ByteArray, LongArray, etc.) disponen de la propiedad indices. Esta propiedad nos devuelve un rango con todos los índices válidos del array.

val numeros = intArrayOf(10, 20, 30)

for (i in numeros.indices) {
    println("Elemento en posición $i = ${numeros[i]}")
}

Uso de índices

Usar indices es más seguro que 0..numeros.size-1, ya que siempre se ajusta al tamaño real del array.

Clase `Array`¶

Kotlin también dispone de una clase genérica llamada Array<T>, que permite almacenar cualquier tipo de dato, incluidos objetos.

fun main() {
    val precios = arrayOf(10.5, 20.0, 30.25)

    println("Listado de precios:")
    for (precio in precios) {
        println(precio)
    }
}

También podemos crear un array vacío o con valores nulos:

val numeros = arrayOfNulls<Int>(4)
numeros[0] = 100
println(numeros.joinToString())

Info

arrayOf() crea un array con los valores indicados.
arrayOfNulls<T>(n) crea un array de tamaño n con valores iniciales null.
.joinToString() une los valores del array en una cadena legible.

Funciones y arrays: parámetros y retornos¶

Las funciones pueden recibir arrays como parámetros o devolverlos como resultado. Esto nos permite modularizar aún más el código.

Función que recibe un array¶

fun mostrarMayores(arreglo: IntArray, limite: Int) {
    for (valor in arreglo) {
        if (valor > limite) println("Valor mayor que $limite: $valor")
    }
}

fun main() {
    val datos = intArrayOf(3, 9, 15, 7, 20)
    mostrarMayores(datos, 10)
}

Función que devuelve un array¶

fun generarPares(n: Int): IntArray {
    val resultado = IntArray(n)
    for (i in resultado.indices) {
        resultado[i] = (i + 1) * 2
    }
    return resultado
}

fun main() {
    val pares = generarPares(5)
    println(pares.joinToString()) // 2, 4, 6, 8, 10
}

Arrays en Jetpack Compose¶

Integramos arrays con UI reactiva, mostrando una lista dinámica.

@Composable
fun ListaNombres() {
    val nombres = arrayOf("Ana", "Carlos", "Lucía", "Marta", "Ginés")
    val mayores = nombres.filter { it.length > 4 }

    Column(
        modifier = Modifier
            .fillMaxSize()
            .padding(16.dp)
    ) {
        Text("Listado de nombres:", style = MaterialTheme.typography.titleLarge)
        nombres.forEach { Text(it) }

        Spacer(Modifier.height(16.dp))

        Text("Nombres con más de 4 letras:", style = MaterialTheme.typography.titleMedium)
        mayores.forEach { Text(it) }
    }
}

Actividades¶

AC 405 (RA2 / CE2a / IC1 / 1p). Implementa una pantalla en Compose con un OutlinedTextField para capturar un nombre y un botón “Mostrar”. Crea una función mostrarNombre(nombre: String): String (pura) que devuelva el nombre y úsala para pintar un Text reactivo. Valida entradas vacías y deshabilita el botón si procede.
AC 406 (RA2 / CE2a / IC1 / 1p). Crea una pantalla en Compose con tres OutlinedTextField numéricos y un botón “Calcular promedio”. Implementa calcularPromedio(a: Double, b: Double, c: Double): Double. Muestra el resultado formateado a 2 decimales y controla errores (no numérico, vacío). El botón solo debe habilitarse si las 3 entradas son válidas.
AC 407 (RA2 / CE2a / IC1 / 1p). Diseña una app Compose con un OutlinedTextField numérico y un botón “Validar múltiplo de 5”. Implementa una función esMultiploDe5(n: Int): Boolean y úsala para mostrar un Text de estado. Añade feedback visual (p. ej., borde de error en el campo) cuando el valor no sea numérico o esté vacío.
AC 408 (RA2 / CE2a / IC1 / 1p). Implementa en Compose una función local formatearNombre(input: String): String dentro del composable principal que capitalice solo la primera letra y ponga el resto en minúsculas (ten en cuenta nombres con espacios). Muestra en tiempo real el nombre formateado mientras el usuario escribe.
AC 409 (RA2 / CE2a / IC1 / 1p). Crea una pantalla Compose que permita introducir N números (lista dinámica) y muestre: suma, media y desviación estándar. Separa la lógica en funciones puras (sumatoria, media, desviacionEstandar). La UI debe reaccionar al añadir/eliminar elementos.
AC 410 (RA2 / CE2a / IC1 / 1p). Construye un mini ranking en Compose con nombre:String y puntos:Int. Usa un array/lista en memoria y muestra la clasificación ordenada descendente. Extrae la ordenación a una función pura ordenarPorPuntos(...). Permite limpiar el ranking y vuelve a calcular automáticamente.
AP 411 (RA2 / CE2a / IC1 / 1p). Diseña una pantalla Compose que reciba varias edades y pinte un histograma textual por tramos (0–17, 18–64, 65+), generando cada barra con una función barra(n: Int): String (p. ej., repitiendo “█”). Separa la clasificación por grupos en una función pura.
AP 412 (RA2 / CE2a / IC1 / 1p). Implementa en Compose un buscador en una lista de nombres (array predefinido). Crea una función filtrarNombres(origen: Array<String>, query: String): List<String> que ignore mayúsculas/minúsculas y tildes. La lista se debe actualizar reactivamente conforme escribe el usuario.
AP 413 (RA2 / CE2a / IC1 / 1p). Crea una pantalla Compose que gestione un inventario (nombre y cantidad). Implementa funciones puras para: totalUnidades, mediaStock, y maxStock. La UI debe permitir alta y baja de elementos y recalcular métricas al momento.
AR 414 (RA2 / CE2a / IC1 / 1p). Implementa una app Compose que capture una secuencia de enteros y muestre solo los primos usando una función pura esPrimo(n: Int): Boolean. Añade un conmutador (switch) para alternar entre mostrar “Todos” y “Solo primos”, manteniendo una única fuente de verdad y recomposición eficiente.
AP 415 (RA2 / CE2a / IC1 / 1p). Realiza un programa que permita ordenar un array por el método de la burbuja. El array se ha de generar aleatoriamente, mostrar los datos y, al pulsar el botón, mostrar el array ordenado.