Array de Kotlin

Array es una de las estructuras de datos más fundamentales en prácticamente todos los lenguajes de programación. La idea detrás de una array es almacenar varios elementos del mismo tipo de datos, como un número entero o una string , bajo un solo nombre de variable.
Las arrays se utilizan para organizar datos en la programación de modo que un conjunto relacionado de valores se pueda ordenar o buscar fácilmente.
Aquí hay algunas propiedades básicas de las arrays:

• Se almacenan en ubicaciones de memoria contiguas.
• Se puede acceder a ellos mediante programación a través de sus índices (arreglo[1], arreglo[0], etc.)
• Son mutables.
• Su tamaño es fijo.

Para obtener más información sobre la estructura de datos de arrays, consulte los tutoriales de arrays .

Creando una array –

En Kotlin, las arrays no son un tipo de datos nativo, sino una colección mutable de elementos similares que están representados por la clase Array.
Hay dos formas de definir una array en Kotlin.

Usando la arrayOf()función –

Podemos usar la función de biblioteca arrayOf()para crear una array pasando los valores de los elementos a la función.
Sintaxis:

val num = arrayOf(1, 2, 3, 4)   //implicit type declaration
val num = arrayOf<Int>(1, 2, 3) //explicit type declaration

Programa Kotlin para crear una array usando las funciones arrayOf() y arrayOf<Int>-

fun main()
{
    // declaring an array using arrayOf()
    val arrayname = arrayOf(1, 2, 3, 4, 5)
    for (i in 0..arrayname.size-1)
    {
        print(" "+arrayname[i])
    }
    println()
    // declaring an array using arrayOf<Int>
    val arrayname2 = arrayOf<Int>(10, 20, 30, 40, 50)
    for (i in 0..arrayname2.size-1)
    {
        print(" "+arrayname2[i])
    }
}

Producción:

 1 2 3 4 5
 10 20 30 40 50

Usando el constructor de arrays –

Dado que Array es una clase en Kotlin, también podemos usar el constructor Array para crear una array.
El constructor toma dos parámetros:

1. El tamaño de la array y
2. Una función que acepta el índice de un elemento dado y devuelve el valor inicial de ese elemento.

Sintaxis:

 val num = Array(3, {i-> i*1})

En el ejemplo anterior, pasamos el tamaño de la array como 3 y una expresión lambda que inicializa los valores de los elementos de 0 a 9.

Programa Kotlin para crear una array usando un constructor –

fun main()
{
    val arrayname = Array(5, { i -> i * 1 })
    for (i in 0..arrayname.size-1)
    {
        println(arrayname[i])
    }
}

Producción:

0
1
2
3
4

Aparte de estos, Kotlin también tiene algunos métodos de fábrica integrados para crear arrays de tipos de datos primitivos, como byteArray, intArray, shortArray, etc. Estas clases no amplían la clase Array; sin embargo, implementan los mismos métodos y propiedades.

Por ejemplo, el método de fábrica para crear una array de enteros es:

val num = intArrayOf(1, 2, 3, 4)

Otros métodos de fábrica disponibles para crear arreglos:

• byteArrayOf()
• charArrayOf()
• arrayCortaDe()
• largaArrayOf()

Acceder y modificar arreglos –

Hasta ahora, hemos visto cómo crear e inicializar una array en Kotlin. Ahora, veamos cómo acceder a ellos y modificarlos.
Nuevamente, hay dos formas de hacer esto:

Uso get()y set()métodos –

Como sabes, una array en Kotlin es básicamente una clase . Por lo tanto, podemos acceder a los datos de un objeto de clase a través de sus funciones miembro. Se dice que las funciones get()y set()son funciones miembro.

El get()método toma un único parámetro: el índice del elemento y devuelve el valor del elemento en ese índice.
Sintaxis:

val x = num.get(0)

El set()método toma 2 parámetros: el índice del elemento y el valor a insertar.
Sintaxis:

num.set(1, 3)

El código anterior establece el valor del segundo elemento de la array en 3

Usando el operador de índice [ ] –

El [ ]operador se puede utilizar para acceder y modificar arrays.
Para acceder a un elemento de array, la sintaxis sería:

val x = num[1]

Esto asignará el valor del segundo elemento en num a x .

Para modificar un elemento de la array, debemos hacer:

num[2] = 5;

Esto cambiará el valor del tercer elemento en la array numérica a 5.

Nota: Internamente, el operador de índice o [ ] es en realidad un operador sobrecargado (ver sobrecarga de operadores) y solo representa llamadas a las funciones miembro get()y set().

Aquí hay un ejemplo de trabajo de la manipulación de arrays de Kotlin en el que creamos una array, modificamos sus valores y accedemos a un elemento en particular:

fun main()
{   // declare an array using arrayOf()
    val num = arrayOf(1, 2, 3, 4, 5)
  
    num.set(0, 10)  // set the first element equal to 10
    num.set(1, 6)   // set the secondelement equal to 6
  
    println(num.get(0)) // print the first element using get()
    println(num[1]) // print the second element using []
}

Producción:

10
6

Arrays transversales –

Una propiedad importante de una array es que se puede recorrer mediante programación y cada elemento de la array se puede manipular individualmente. Kotlin admite algunas formas poderosas de atravesar una array.

El modismo más simple y más comúnmente usado cuando se trata de atravesar una array es usar el bucle for .
Sintaxis:

for(i in num.indices){
      println(num[i])
  }

Programa Kotlin de recorrido de array usando for loop-

// Traversing an array
fun main()
{
    val num = arrayOf<Int>(1, 2, 3, 4, 5)
    num.set(0, 10)
    num.set(1, 6)
    for (i in num.indices)
    {
        println(num[i])
    }
}

Producción:

10
6
3
4
5

Alternativamente, podemos usar el rango para lograr el mismo efecto. En Kotlin, un rango es un intervalo entre dos valores (inicio y final) y se puede crear usando el operador (..) . El recorrido a través del rango se puede hacer usando la palabra clave in .
Sintaxis para rango:

for (i in 0..10){
    println(i)
}

El rango de elementos en una array se define de 0 a tamaño 1. Entonces, para atravesar una array usando el rango, ejecutamos un ciclo de 0 a tamaño 1 en el nombre de la array.
Programa Kotlin de recorrido de array usando range-

// Traversing an array
fun main()
{
    val arrayname = arrayOf<Int>(1, 2, 3, 4, 5)
    for (i in 0..arrayname.size-1)
    {
        println(arrayname[i])
    }
}

Producción:

1
2
3
4
5

Otra forma posiblemente menos tediosa de hacer lo anterior es usar el ciclo foreach .

Sintaxis:

arrayname.forEach({index->println(index)})

Programa Kotlin de recorrido de array usando foreach loop-

// Traversing an array
fun main()
{
    val arrayname = arrayOf<Int>(1, 2, 3, 4, 5)
    arrayname.forEach({ index -> println(index) })
}

Producción:

1
2
3
4
5