Der ultimative Leitfaden zum Initialisieren von Listen in Kotlin

1. Initialisieren Sie unveränderliche Listen in Kotlin
2. Veränderliche Listen in Kotlin initialisieren

Eine Kotlin-List<T> bezieht sich auf eine Sammlung mehrerer Elemente. Das <T> in der Syntax bezeichnet einen undefinierten Datentyp. Das bedeutet, dass eine mit List<T> initialisierte Liste keinen bestimmten Datentyp hat.

Mit vordefinierten Funktionen der Klasse Collections können wir jederzeit auf die Elemente einer Liste zugreifen und sie ändern.

Wir können zwei Arten von Listen in Kotlin initialisieren, die unveränderlich und veränderlich sind. Es gibt verschiedene Möglichkeiten, diese Listen zu initialisieren, und wir werden sie in diesem Artikel sehen.

Initialisieren Sie unveränderliche Listen in Kotlin

Unveränderliche Listen sind Sammlungen, die nach ihrer Erstellung nicht mehr geändert werden können. Sie werden mit der List-Schnittstelle definiert und durch die List-Implementierungsklassen wie List und ArrayList dargestellt.

Wir werden drei Möglichkeiten kennenlernen, unveränderliche Listen zu initialisieren. Diese drei Methoden umfassen Folgendes:

1. ListeVon()
2. leereListe()
3. ListeOfNotNull()

Initialisieren Sie Kotlin-Listen mit der Funktion listOf()

Die listOf() ist die Top-Level-Funktion aus der Collections-Klasse. Diese Methode erstellt eine unveränderliche Liste von Elementen. Es ähnelt der Verwendung von Arrays.asList in Java.

Sie können unveränderliche Kotlin-Listen mit der folgenden Syntax initialisieren.

val listName = listOf(item1, item2, item3)

Jetzt erstellen wir ein einfaches Kotlin-Programm mit der obigen Syntax. In diesem Programm erstellen wir eine unveränderliche Kotlin-Liste mit dem Namen Fruits und fügen ein paar Früchte hinzu.

fun main(args: Array<String>) {
    val Fruits = listOf("Apple", "Mango", "Strawberry")
    println(Fruits)
}

Dies ist eine unveränderliche Liste. Daher führt die Verwendung vordefinierter Methoden zum Ändern der Liste zu einem Fehler.

Wir werden dies in Aktion sehen, indem wir die Funktion add() verwenden, um zu versuchen, ein Element zu derselben unveränderlichen Liste hinzuzufügen, die wir im vorherigen Beispiel definiert haben.

fun main(args: Array<String>) {
    val Fruits = listOf("Apple", "Mango", "Strawberry")
    println(Fruits)
    Fruits.add("Kiwi")
    println(Fruits)
}

Wie wir in der Ausgabe sehen, wirft die Methode add() einen unresolved reference: add-Fehler.

Initialisieren Sie Kotlin-Listen mit der Funktion emptyList()

Die nächste Möglichkeit, eine unveränderliche Kotlin-Liste zu erstellen, ist die Verwendung der Funktion emptyList(). Sie funktioniert ähnlich wie die Funktion listOf(), mit dem einzigen Unterschied, dass sie eine leere Liste erstellt.

Das bedeutet, es wird eine Liste erstellt, aber es findet keine Initialisierung statt, da die Liste leer ist.

Die Syntax zur Verwendung der Funktion emptyList() lautet wie folgt:

val listName: List<String/Int> = emptyList()

Hier ist ein Programm, das die Verwendung von emptyList() demonstriert, um eine leere unveränderliche Liste in Kotlin zu erstellen.

fun main() {
    val emptyImmutableList: List<String> = emptyList()
    println(emptyImmutableList)
}

Initialisieren Sie Kotlin-Listen mit der Funktion listOfNotNull()

Die Funktion listOfNotNull() gibt eine neue Liste aus einer bestehenden Sammlung ohne null zurück.

Wenn Sie eine Liste mit einigen String- und einigen null-Werten haben, erhalten Sie mit dieser Methode eine neue Liste mit nur den String-Werten. Wenn die Liste jedoch nur null-Werte enthält, gibt die Funktion eine leere Liste zurück.

Die resultierende Liste ist schreibgeschützt. Daher dient die Funktion listOfNotNull() dazu, eine unveränderliche Kotlin-Liste zu initialisieren.

Hier ist die Syntax der Funktion listOfNotNull().

fun <T : Any> listOfNotNull(element: T?): List<T>

Im folgenden Programm erstellen wir drei Listen. Einer hat nur null-Werte, der zweite hat nur Nicht-Null-Werte und der dritte hat eine Mischung aus null- und Nicht-Null-Werten.

fun main(args: Array<String>) {
    val nullValuesList = listOfNotNull(null, null)
    println(nullValuesList)

    val nonNullValuesList = listOfNotNull(13, "Hello", "Hi", 96)
    println(nonNullValuesList)

    val mixList = listOfNotNull(13, null, "Hello", null, 96)
    println(mixList)
}

Die erste println()-Funktion ergibt eine leere Liste, weil es in der ersten Liste nullValuesList nur zwei null-Werte gibt. Die zweite println()-Funktion druckt alle Elemente der zweiten Liste nonNullValuesList, da sie nur non-null-Werte enthält.

Die dritte println()-Funktion druckt jedoch eine Liste, die nur Nicht-Null-Werte aus mixList enthält.

Veränderliche Listen in Kotlin initialisieren

Veränderliche Listen sind veränderbare Sammlungen, auf die wir bei Bedarf zugreifen und die wir ändern können. In diesem Abschnitt werden zwei Möglichkeiten zum Initialisieren von Kotlin-Listen betrachtet.

Die beiden Methoden, die wir durchlaufen werden, sind die folgenden:

1. mutableListOf()
2. arrayListOf()

Initialisieren Sie Kotlin-Listen mit der Funktion mutableListOf()

Die erste Möglichkeit, veränderliche Kotlin-Listen zu initialisieren, ist die Methode mutableListOf(). Wie die Funktion listOf() erlaubt auch mutableListOf() das Erstellen und Initialisieren einer Kotlin-List.

Diese Funktion erstellt jedoch eine veränderliche Liste, was bedeutet, dass Sie die Elemente aus dieser Liste hinzufügen oder löschen können.

Die Syntax von mutableListOf() lautet:

var listName = mutableListOf(item1, item2, item3)

Wir werden unten ein Kotlin-Programm erstellen, um eine veränderliche Liste mit dem Namen Früchte zu erstellen und zu initialisieren. Als Nächstes fügen wir der Liste ein neues Element hinzu und entfernen ein weiteres Element.

fun main(args: Array<String>) {
    var Fruits = mutableListOf("Apple", "Mango", "Strawberry")
    println(Fruits)

    // Adding a new element to the list
    Fruits.add("Kiwi")
    println(Fruits)

    // Removing an element from the list
    Fruits.remove("Mango")
    println(Fruits)
}

Wie wir in der Ausgabe sehen, wirft die Funktion add() diesmal keinen unresolved reference-Fehler. Dies liegt daran, dass die von uns erstellte Liste veränderlich ist.

Initialisieren Sie Kotlin-Listen mit der Funktion arrayListOf()

Die andere Möglichkeit, eine veränderliche Kotlin-Liste zu initialisieren, ist die Funktion arrayListOf(). Diese Methode erstellt und initialisiert ein Array.

Die Syntax der Funktion arrayListOf() lautet:

var listName = arrayListOf(item1, item2, item3)

Wir werden die obige Syntax verwenden, um eine veränderliche Kotlin-ArrayList namens Cars zu erstellen und sie mit einigen Automobilmarken zu initialisieren. Wir werden dann der ArrayList neue Elemente hinzufügen, um zu bestätigen, dass sie änderbar ist.

fun main(args: Array<String>) {
    var Cars = arrayListOf("Mercedes Benz", "BMW", "Bentley")
    println(Cars)

    Cars += listOf("Ferrari", "Lamborghini")
    println(Cars)
}