Come inizializzare un array in Kotlin con valori?

In Java un array può essere inizializzato come:

int numbers[] = new int[] {10, 20, 30, 40, 50}

Come si presenta l'inizializzazione dell'array di Kotlin?

val numbers: IntArray = intArrayOf(10, 20, 30, 40, 50)

Vedi Kotlin - Tipi di base per i dettagli.

Puoi anche fornire una funzione di inizializzazione come secondo parametro:

val numbers = IntArray(5) { 10 * (it + 1) }
// [10, 20, 30, 40, 50]

Vale la pena ricordare che quando si utilizza builtines Kotlin (ad esempio intArrayOf(), longArrayOf(), arrayOf(), ecc) non sono in grado di inizializzare l'array con i valori di default (o tutti i valori di valore desiderato) per una data dimensione, invece è necessario fare di inizializzazione tramite chiamando in base al costruttore della classe .

// Array of integers of a size of N
val arr = IntArray(N)

// Array of integers of a size of N initialized with a default value of 2
val arr = IntArray(N) { i -> 2 }

Ecco un esempio:

fun main(args: Array<String>) {
    val arr = arrayOf(1, 2, 3);
    for (item in arr) {
        println(item);
    }
}

È inoltre possibile utilizzare un parco giochi per testare le funzionalità della lingua.

In Kotlin ci sono diversi modi.

var arr = IntArray(size) // construct with only size

Quindi semplicemente il valore iniziale degli utenti o di un'altra raccolta o dove vuoi.

var arr = IntArray(size){0}  // construct with size and fill array with 0
var arr = IntArray(size){it} // construct with size and fill with its index

Possiamo anche creare array con funzioni integrate come-

var arr = intArrayOf(1, 2, 3, 4, 5) // create an array with 5 values

Un altro modo

var arr = Array(size){0} // it will create an integer array
var arr = Array<String>(size){"$it"} // this will create array with "0", "1", "2" and so on.

È inoltre possibile utilizzare doubleArrayOf()o DoubleArray()qualsiasi tipo di primitiva anziché Int.

In Kotlin possiamo creare matrice usando arrayOf(), intArrayOf(), charArrayOf(), booleanArrayOf(), longArrayOf()funzioni.

Per esempio:

var Arr1 = arrayOf(1,10,4,6,15)  
var Arr2 = arrayOf<Int>(1,10,4,6,15)  
var Arr3 = arrayOf<String>("Surat","Mumbai","Rajkot")  
var Arr4 = arrayOf(1,10,4, "Ajay","Prakesh")  
var Arr5: IntArray = intArrayOf(5,10,15,20)  

Vecchia domanda, ma se desideri utilizzare un intervallo:

var numbers: IntArray = IntRange(10, 50).step(10).toList().toIntArray()

Produce quasi lo stesso risultato di:

var numbers = Array(5, { i -> i*10 + 10 })

risultato: 10, 20, 30, 40, 50

Penso che la prima opzione sia un po 'più leggibile. Entrambi funzionano.

puoi usare questo metodo

var numbers=Array<Int>(size,init)
var numbers=IntArray(size,init)
var numbers= intArrayOf(1,2,3)

esempio

var numbers = Array<Int>(5, { i -> 0 })

init rappresenta il valore predefinito (inizializza)

Lingua Kotlin è specializzata classi per la rappresentazione di array di tipi primitivi, senza boxe in testa: per esempio - IntArray, ShortArray, ByteArray, ecc ho bisogno di dire che queste classi non hanno alcuna relazione eredità al genitore Arraydi classe, ma hanno lo stesso insieme di metodi e proprietà. Ognuno di essi ha anche una corrispondente funzione di fabbrica. Quindi, per inizializzare un array con valori in Kotlin devi solo digitare questo:

val myArr: IntArray = intArrayOf(10, 20, 30, 40, 50)

... o in questo modo:

val myArr = Array<Int>(5, { i -> ((i+1) * 10) })

myArr.forEach { println(it) }                                // 10, 20, 30, 40, 50

Ora puoi usarlo:

myArr[0] = (myArr[1] + myArr[2]) - myArr[3]

Spero che questo ti aiuti.

Penso che una cosa che vale la pena menzionare e che non sia abbastanza intuitiva dalla documentazione sia che, quando si utilizza una funzione di fabbrica per creare un array e si specifica la sua dimensione, l'array viene inizializzato con valori uguali ai loro valori di indice. Ad esempio, in un array come questo: val array = Array(5, { i -> i })i valori iniziali sono assegnati [0,1,2,3,4]e non dire, [0,0,0,0,0]. Questo è il motivo per cui dalla documentazione, val asc = Array(5, { i -> (i * i).toString() })produce una risposta di["0", "1", "4", "9", "16"]

È possibile creare un array Int come questo:

val numbers = IntArray(5, { 10 * (it + 1) })

5 è la dimensione della matrice Int. la funzione lambda è l'elemento init. intervallo 'it' in [0,4], più 1 intervallo di make in [1,5]

la funzione di origine è:

 /**
 * An array of ints. When targeting the JVM, instances of this class are 
 * represented as `int[]`.
 * @constructor Creates a new array of the specified [size], with all elements 
 *  initialized to zero.
 */
 public class IntArray(size: Int) {
       /**
        * Creates a new array of the specified [size], where each element is 
        * calculated by calling the specified
        * [init] function. The [init] function returns an array element given 
        * its index.
        */
      public inline constructor(size: Int, init: (Int) -> Int)
  ...
 }

Classe IntArray definita in Arrays.kt

Puoi provare questo:

var a = Array<Int>(5){0}

Puoi semplicemente usare i metodi di libreria standard esistenti come mostrato qui:

val numbers = intArrayOf(10, 20, 30, 40, 50)

Potrebbe avere senso usare un costruttore speciale però:

val numbers2 = IntArray(5) { (it + 1) * 10 }

Si passa una dimensione e una lambda che descrivono come avviare i valori. Ecco la documentazione:

/**
 * Creates a new array of the specified [size], where each element is calculated by calling the specified
 * [init] function. The [init] function returns an array element given its index.
 */
public inline constructor(size: Int, init: (Int) -> Int)

Mi chiedo perché nessuno abbia dato le risposte più semplici:

val array: Array<Int> = [1, 2, 3]

Secondo uno dei commenti alla mia risposta originale, mi sono reso conto che funziona solo quando usato negli argomenti delle annotazioni (il che è stato davvero inaspettato per me).

Sembra che Kotlin non consenta di creare letterali array all'esterno delle annotazioni.

Ad esempio, guarda questo codice usando @Option dalla libreria args4j:

    @Opzione(
        name = "-h",
        alias = ["--help", "-?"],
        use = "Mostra questo aiuto"
    )
    var help: Boolean = false

L'argomento opzione "alias" è di tipo Array<String>

Nel mio caso, devo inizializzare gli elementi del mio cassetto. Compilare i dati con il codice seguente.

    val iconsArr : IntArray = resources.getIntArray(R.array.navigation_drawer_items_icon)
    val names : Array<String> = resources.getStringArray(R.array.navigation_drawer_items_name)


    // Use lambda function to add data in my custom model class i.e. DrawerItem
    val drawerItems = Array<DrawerItem>(iconsArr.size, init = 
                         { index -> DrawerItem(iconsArr[index], names[index])})
    Log.d(LOGGER_TAG, "Number of items in drawer is: "+ drawerItems.size)

Classe del modello personalizzato

class DrawerItem(var icon: Int, var name: String) {

}

Dichiarare int array a livello globale

var numbers= intArrayOf()

Il prossimo metodo onCreate inizializza l'array con valore

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    //create your int array here
    numbers= intArrayOf(10,20,30,40,50)
}

In Java un array può essere inizializzato come:

int numbers[] = new int[] {10, 20, 30, 40, 50}

Ma in Kotlin un array ha inizializzato molti modi come:

Qualsiasi tipo generico di array è possibile utilizzare la funzione arrayOf () :

val arr = arrayOf(10, 20, 30, 40, 50)

val genericArray = arrayOf(10, "Stack", 30.00, 40, "Fifty")

Utilizzando le funzioni di utilità di Kotlin è possibile inizializzare un array

val intArray = intArrayOf(10, 20, 30, 40, 50)

Modo semplice:

Per intero:

var number = arrayOf <Int> (10, 20, 30, 40, 50)

Mantieni tutti i tipi di dati

var number = arrayOf (10, "valore stringa", 10.5)

inizializzare l'array in questo modo: val paramValueList : Array<String?> = arrayOfNulls<String>(5)

In questo modo, puoi inizializzare l'array int in koltin.

 val values: IntArray = intArrayOf(1, 2, 3, 4, 5,6,7)

La mia risposta completa @maroun questi sono alcuni modi per inizializzare un array:

Usa un array

val numbers = arrayOf(1,2,3,4,5)

Utilizzare un array rigoroso

val numbers = intArrayOf(1,2,3,4,5)

Mescola i tipi di matrici

val numbers = arrayOf(1,2,3.0,4f)

Matrici di nidificazione

val numbersInitials = intArrayOf(1,2,3,4,5)
val numbers = arrayOf(numbersInitials, arrayOf(6,7,8,9,10))

Possibilità di iniziare con codice dinamico

val numbers = Array(5){ it*2}