Kotlin
Array

Array generici

Gli array generici in Kotlin sono rappresentati da Array<T> .

Per creare un array vuoto, utilizzare la funzione emptyArray<T>() :

val empty = emptyArray<String>()

Per creare un array con dimensioni e valori iniziali specifici, utilizzare il costruttore:

var strings = Array<String>(size = 5, init = { index -> "Item #$index" })
print(Arrays.toString(a)) // prints "[Item #0, Item #1, Item #2, Item #3, Item #4]"
print(a.size) // prints 5

Le matrici hanno get(index: Int): T e set(index: Int, value: T) funzioni:

strings.set(2, "ChangedItem")
print(strings.get(2)) // prints "ChangedItem"

// You can use subscription as well:
strings[2] = "ChangedItem"
print(strings[2]) // prints "ChangedItem"

Matrici di primitivi

Questi tipi non ereditano dalla Array<T> per evitare la boxe, tuttavia hanno gli stessi attributi e metodi.

estensioni

average() è definito per Byte , Int , Long , Short , Double , Float e restituisce sempre Double :

val doubles = doubleArrayOf(1.5, 3.0)
print(doubles.average()) // prints 2.25

val ints = intArrayOf(1, 4)
println(ints.average()) // prints 2.5

component1() , component2() , ... component5() restituisce un elemento dell'array

getOrNull(index: Int) restituisce null se index è fuori limite, altrimenti un elemento dell'array

first() , last()

toHashSet() restituisce un HashSet<T> di tutti gli elementi

sortedArray() , sortedArrayDescending() crea e restituisce un nuovo array con elementi ordinati di corrente

sort() , sortDescending ordina l'array sul posto

min() , max()

Iterate Array

È possibile stampare gli elementi dell'array utilizzando il loop stesso del ciclo avanzato Java, ma è necessario modificare la parola chiave da : a in .

val asc = Array(5, { i -> (i * i).toString() })
for(s : String in asc){
    println(s);
}

È inoltre possibile modificare il tipo di dati in ciclo for.

val asc = Array(5, { i -> (i * i).toString() })
for(s in asc){
    println(s);
}

Crea un array

val a = arrayOf(1, 2, 3) // creates an Array<Int> of size 3 containing [1, 2, 3].

Crea un array usando una chiusura

val a = Array(3) { i -> i * 2 } // creates an Array<Int> of size 3 containing [0, 2, 4]

Crea una matrice non inizializzata

val a = arrayOfNulls<Int>(3) // creates an Array<Int?> of [null, null, null]

L'array restituito avrà sempre un tipo nullable. Le matrici di elementi non annullabili non possono essere create non inizializzate.