Kotlin Academy · Lektion

Destrukturierende Deklarationen

Packen Sie Werte in Variablen aus

Destrukturierende Deklarationen ist eine kostenlose Kotlin Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Kotlin Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Kotlin Academy-Kurs umfasst insgesamt 4 Lektionen.

Objekte entpacken

Manchmal möchten Sie mehrere Eigenschaften gleichzeitig aus einem Objekt auslesen.

Mit Kotlin-Destrukturierungsdeklarationen können Sie mehrere Variablen in einer einzigen Zeile aus einem Objekt zuweisen.

Grundlegende Destrukturierung

Setzen Sie links von = Namen in Klammern. Kotlin weist ihnen die Komponenten des Objekts der Reihe nach zu.

Datenklassen unterstützen dies automatisch.

data class User(val name: String, val age: Int)

fun main() {
    val user = User("Alice", 30)
    val (name, age) = user
    println(name)
    println(age)
}

So funktioniert es

Hinter den Kulissen ruft die Destrukturierung generierte component1()-, component2()-Funktionen und weitere auf.

Die Position jeder Variablen entspricht der passenden Komponentenfunktion.

data class Point(val x: Int, val y: Int)

fun main() {
    val p = Point(3, 7)
    println(p.component1())
    println(p.component2())
}

Die Reihenfolge ist entscheidend

Variablen werden anhand ihrer Position und nicht anhand ihres Namens zugeordnet.

Die erste Variable erhält immer die erste Konstruktor-Eigenschaft – unabhängig davon, wie Sie sie nennen.

data class Pair2(val first: Int, val second: Int)

fun main() {
    val (a, b) = Pair2(10, 20)
    println(a) // first property
    println(b) // second property
}

Komponenten überspringen

Verwenden Sie einen Unterstrich _, um eine nicht benötigte Komponente zu überspringen.

So bleibt Ihr Code übersichtlich, wenn nur einige Werte relevant sind.

data class User(val name: String, val age: Int, val city: String)

fun main() {
    val (name, _, city) = User("Mia", 28, "Paris")
    println(name)
    println(city)
}

Destrukturierung in Schleifen

Beim Iterieren über Collections von Objekten spielt die Destrukturierung ihre Stärken aus.

Sie können jedes Element direkt im for-Kopf entpacken.

data class User(val name: String, val age: Int)

fun main() {
    val users = listOf(User("A", 20), User("B", 25))
    for ((name, age) in users) {
        println(name + " is " + age)
    }
}

Map-Einträge destrukturieren

Maps unterstützen die Destrukturierung, weil ihre Einträge Komponenten für Schlüssel und Wert bereitstellen.

Dadurch wird die Iteration über eine Map sehr übersichtlich.

fun main() {
    val scores = mapOf("Alice" to 90, "Bob" to 85)
    for ((name, score) in scores) {
        println(name + ": " + score)
    }
}

Mehrere Werte zurückgeben

Eine Funktion kann eine Datenklasse zurückgeben, und der Aufrufer kann das Ergebnis destrukturieren.

Das ist eine übersichtliche Alternative zu Ausgabeparametern.

data class MinMax(val min: Int, val max: Int)

fun minMax(nums: List<Int>): MinMax {
    return MinMax(nums.min(), nums.max())
}

fun main() {
    val (low, high) = minMax(listOf(3, 1, 8, 5))
    println(low)
    println(high)
}

Pair und Triple destrukturieren

Auch Pair und Triple der Standardbibliothek unterstützen die Destrukturierung.

Sie eignen sich gut für schnelle Gruppierungen, ohne dass Sie eine Klasse definieren müssen.

fun main() {
    val pair = Pair("x", 1)
    val (label, value) = pair
    println(label)
    println(value)
}

Destrukturierung von Lambda-Parametern

Sie können direkt in der Parameterliste eines Lambdas destrukturieren.

Das ist üblich, wenn Sie über Einträge oder Paare mappen.

fun main() {
    val map = mapOf(1 to "one", 2 to "two")
    val text = map.map { (key, value) -> "" + key + "=" + value }
    println(text)
}

Alles zusammenführen

Durch die Destrukturierung werden Objekte in Variablen entpackt:

Verwenden Sie auf der linken Seite von = Klammern
Komponenten werden anhand ihrer Position zugeordnet
Überspringen Sie Komponenten mit _
Funktioniert in Schleifen, Lambdas und Rückgabewerten

data class Result(val ok: Boolean, val message: String)

fun main() {
    val (ok, message) = Result(true, "done")
    println(ok)
    println(message)
}

Kurzer Test

Testen Sie Ihr Verständnis von Destrukturierungsdeklarationen.

Zusammenfassung

Sie haben Destrukturierungsdeklarationen kennengelernt:

Sie entpacken ein Objekt in mehrere Variablen
Die Zuordnung erfolgt anhand der Position über componentN()
_ überspringt nicht benötigte Komponenten
Sie funktionieren in Schleifen, Maps, Lambdas und Rückgabewerten

Als Nächstes verwenden Sie Datenklassen in Collections wie Sets und Maps.

Häufig gestellte Fragen

Ist die Lektion „Destrukturierende Deklarationen“ kostenlos?

Ja — der vollständige Text von „Destrukturierende Deklarationen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Kotlin Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Kotlin Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Destrukturierende Deklarationen“?

Packen Sie Werte in Variablen aus Du übst Kotlin Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Kotlin Academy zu starten?

Keine Vorkenntnisse erforderlich. Kotlin Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Destrukturierende Deklarationen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Kotlin Academy-Lektion Code schreiben und ausführen?

Ja. Jede Kotlin Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Kotlin Academy