Wie initialisiere ich ein Array in Kotlin mit Werten?

In Java kann ein Array wie folgt initialisiert werden:

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

Wie sieht die Array-Initialisierung von Kotlin aus?

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

Weitere Informationen finden Sie unter Kotlin - Grundtypen .

Sie können auch eine Initialisierungsfunktion als zweiten Parameter bereitstellen:

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

Erwähnenswert , dass , wenn Kotlin builtines (zB intArrayOf(), longArrayOf(), arrayOf(), etc.) , die Sie nicht in der Lage sind das Array mit den Standardwerten (oder alle Werte auf den gewünschten Wert) für eine bestimmte Größe zu initialisieren, anstatt Sie initialize über Aufruf nach Klassenkonstruktors tun müssen .

// 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 }

Hier ist ein Beispiel:

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

Sie können auch einen Spielplatz verwenden , um Sprachfunktionen zu testen.

In Kotlin gibt es mehrere Möglichkeiten.

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

Dann einfach Anfangswert von Benutzern oder aus einer anderen Sammlung oder wo immer Sie wollen.

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

Wir können auch Arrays mit eingebauten Funktionen wie erstellen

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

Ein anderer Weg

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.

Sie können auch doubleArrayOf()oder DoubleArray()oder einen beliebigen primitiven Typ anstelle von Int verwenden.

In Kotlin können wir Array erstellen arrayOf(), intArrayOf(), charArrayOf(), booleanArrayOf(), longArrayOf()Funktionen.

Beispielsweise:

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)  

Alte Frage, aber wenn Sie einen Bereich verwenden möchten:

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

Ergibt fast das gleiche Ergebnis wie:

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

Ergebnis: 10, 20, 30, 40, 50

Ich denke, die erste Option ist etwas besser lesbar. Beide arbeiten.

Sie können diese Methoden verwenden

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

Beispiel

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

init repräsentiert den Standardwert (initialize)

Kotlin Sprache hat für die Darstellung von Arrays von primitiven Typen Klassen spezialisiert ohne Overhead - Boxen: zum Beispiel - IntArray, ShortArray, ByteArrayetc. Ich muß sagen , dass diese Klassen keinen Erbe Bezug auf die Eltern haben ArrayKlasse, aber sie haben den gleichen Satz von Methoden und Eigenschaften. Jeder von ihnen hat auch eine entsprechende Werksfunktion. Um ein Array mit Werten in Kotlin zu initialisieren, müssen Sie nur Folgendes eingeben:

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

... oder so:

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

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

Jetzt können Sie es verwenden:

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

Hoffe das hilft.

Ich denke, eine Sache, die erwähnenswert und aus der Dokumentation nicht intuitiv genug ist, ist, dass, wenn Sie eine Factory-Funktion zum Erstellen eines Arrays verwenden und dessen Größe angeben, das Array mit Werten initialisiert wird, die ihren Indexwerten entsprechen. In einem Array wie diesem: val array = Array(5, { i -> i })sind die zugewiesenen Anfangswerte [0,1,2,3,4]und sagen nicht , [0,0,0,0,0]. Deshalb ergibt sich aus der Dokumentation val asc = Array(5, { i -> (i * i).toString() })eine Antwort von["0", "1", "4", "9", "16"]

Sie können ein Int-Array wie folgt erstellen:

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

5 ist die Int-Array-Größe. Die Lambda-Funktion ist die Element-Init-Funktion. 'it'-Bereich in [0,4] plus 1 Make-Bereich in [1,5]

Ursprungsfunktion ist:

 /**
 * 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)
  ...
 }

IntArray-Klasse, definiert in Arrays.kt

Sie können dies versuchen:

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

Sie können einfach die vorhandenen Standard - Bibliothek verwenden Methoden wie hier gezeigt:

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

Es kann jedoch sinnvoll sein, einen speziellen Konstruktor zu verwenden:

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

Sie übergeben eine Größe und ein Lambda, die beschreiben, wie die Werte initiiert werden. Hier ist die Dokumentation:

/**
 * 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)

Ich frage mich, warum niemand die einfachsten Antworten gegeben hat:

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

Gemäß einem der Kommentare zu meiner ursprünglichen Antwort wurde mir klar, dass dies nur funktioniert, wenn es in Annotationsargumenten verwendet wird (was für mich wirklich unerwartet war).

Kotlin erlaubt anscheinend nicht, Array-Literale außerhalb von Annotationen zu erstellen.

Sehen Sie sich diesen Code beispielsweise mit @Option aus der args4j-Bibliothek an:

    @Möglichkeit(
        name = "-h",
        Aliase = ["--help", "-?"],
        usage = "Zeige diese Hilfe"
    )
    var help: Boolean = false

Das Optionsargument "Aliase" ist vom Typ Array<String>

In meinem Fall muss ich meine Schubladenelemente initialisieren. Ich fülle die Daten mit dem folgenden Code.

    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)

Benutzerdefinierte Modellklasse-

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

}

Deklarieren Sie das int-Array auf global

var numbers= intArrayOf()

Die nächste onCreate-Methode initialisiert Ihr Array mit value

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 kann ein Array wie folgt initialisiert werden:

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

Aber in Kotlin wurde ein Array auf viele Arten initialisiert, wie zum Beispiel:

Jeder generische Array-Typ, den Sie mit der Funktion arrayOf () verwenden können:

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

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

Mit den Utility-Funktionen von Kotlin kann ein Array initialisiert werden

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

Einfacher Weg:

Für Integer:

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

Halten Sie alle Datentypen

var number = arrayOf (10, "string value", 10.5)

Array auf folgende Weise initialisieren: val paramValueList : Array<String?> = arrayOfNulls<String>(5)

Auf diese Weise können Sie das int-Array in koltin initialisieren.

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

Meine Antwort ergänzt @maroun. Dies sind einige Möglichkeiten, ein Array zu initialisieren:

Verwenden Sie ein Array

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

Verwenden Sie ein striktes Array

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

Mischen Sie Arten von Matrizen

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

Verschachtelungsarrays

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

Möglichkeit, mit dynamischem Code zu beginnen

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