Transformationen
map, filter, flatMap
Transformationen ist eine kostenlose Scala for Backend Engineering & Functional Programming-Lektion auf CoddyKit. Dies ist Lektion 2 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 Scala for Backend Engineering & Functional Programming-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Scala for Backend Engineering & Functional Programming-Kurs umfasst insgesamt 4 Lektionen.
Collections transformieren
Scala-Collections sind standardmäßig unveränderlich. Anstatt sie zu verändern, transformieren Sie sie mit Methoden wie map, filter und flatMap in neue Collections.
object Main {
def main(args: Array[String]): Unit = {
val nums = List(1, 2, 3, 4)
val doubled = nums.map(_ * 2)
println(nums)
println(doubled)
}
}map: jedes Element transformieren
map wendet eine Funktion auf jedes Element an und gibt eine neue Collection mit derselben Größe zurück. Der Elementtyp kann sich ändern.
object Main {
def main(args: Array[String]): Unit = {
val words = List("scala", "rocks")
val lengths = words.map(_.length)
println(lengths)
}
}Die Kurzschreibweise mit Unterstrich
Der Unterstrich _ ist eine Kurzschreibweise für einen einzelnen Funktionsparameter. _ * 2 bedeutet x => x * 2. Dadurch bleiben einfache Transformationen kompakt.
object Main {
def main(args: Array[String]): Unit = {
val nums = List(10, 20, 30)
println(nums.map(_ + 1))
println(nums.map(x => x + 1))
}
}filter: passende Elemente behalten
filter behält nur die Elemente, für die das Prädikat true zurückgibt. Das Ergebnis kann kleiner als das Original sein.
object Main {
def main(args: Array[String]): Unit = {
val nums = (1 to 10).toList
val evens = nums.filter(_ % 2 == 0)
println(evens)
}
}filterNot: das Gegenteil
filterNot behält Elemente, für die das Prädikat false ist. Es bildet das Komplement von filter.
object Main {
def main(args: Array[String]): Unit = {
val nums = List(1, 2, 3, 4, 5)
println(nums.filterNot(_ % 2 == 0))
}
}flatMap: erst abbilden, dann abflachen
flatMap wendet auf jedes Element eine Funktion an, die eine Collection zurückgibt, und flacht die Ergebnisse anschließend zu einer Collection ab.
object Main {
def main(args: Array[String]): Unit = {
val words = List("ab", "cd")
val chars = words.flatMap(_.toList)
println(chars)
}
}map im Vergleich zu flatMap
Wenn Ihre Funktion eine Collection zurückgibt, erzeugt map verschachtelte Collections, während flatMap eine flache Collection erzeugt. Wählen Sie abhängig von der gewünschten Struktur.
object Main {
def main(args: Array[String]): Unit = {
val nums = List(1, 2, 3)
println(nums.map(n => List(n, n)))
println(nums.flatMap(n => List(n, n)))
}
}flatMap mit Option
flatMap über eine Liste von Option-Werten verwirft die None-Werte und entpackt die Some-Werte – eine praktische Möglichkeit, gleichzeitig zu filtern und zu transformieren.
object Main {
def main(args: Array[String]): Unit = {
val raw = List("1", "x", "3", "y")
val parsed = raw.flatMap(_.toIntOption)
println(parsed)
}
}collect: gleichzeitig filtern und abbilden
collect erwartet eine partielle Funktion: Sie behält und transformiert nur die Elemente, für die die Funktion definiert ist, und kombiniert filter und map in einem Durchlauf.
object Main {
def main(args: Array[String]): Unit = {
val mixed: List[Any] = List(1, "two", 3, "four", 5)
val ints = mixed.collect { case i: Int => i * 10 }
println(ints)
}
}Transformationen verketten
Da jede Methode eine neue Collection zurückgibt, können Sie sie zu einer gut lesbaren Pipeline verketten. Jeder Schritt transformiert die Ausgabe des vorherigen.
object Main {
def main(args: Array[String]): Unit = {
val result = List(1, 2, 3, 4)
.map(_ + 1)
.filter(_ % 2 == 0)
println(result)
}
}Eine übersichtliche Pipeline
Hier ist eine übersichtliche Transformationspipeline: gerade Zahlen filtern, quadrieren und anschließend die großen behalten. Pipelines lesen sich wie eine Beschreibung des Datenflusses.
object Main {
def main(args: Array[String]): Unit = {
val result = (1 to 10).toList
.filter(_ % 2 == 0)
.map(x => x * x)
.filter(_ > 10)
println(result)
}
}Schnelltest
Was gibt List("ab", "cd").flatMap(_.toList) zurück?
Zusammenfassung
Sie haben die grundlegenden Transformationen kennengelernt:
map— jedes Element transformieren, gleiche Größefilter/filterNot— Elemente anhand eines Prädikats behalten oder verwerfenflatMap— abbilden und anschließend verschachtelte Ergebnisse abflachencollect— mit einer partiellen Funktion filtern und abbilden- Sie können sie zu übersichtlichen, unveränderlichen Pipelines verketten
Häufig gestellte Fragen
Ist die Lektion „Transformationen“ kostenlos?
Ja — der vollständige Text von „Transformationen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Scala for Backend Engineering & Functional Programming-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Scala for Backend Engineering & Functional Programming-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Transformationen“?
map, filter, flatMap Du übst Scala for Backend Engineering & Functional Programming 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 Scala for Backend Engineering & Functional Programming zu starten?
Keine Vorkenntnisse erforderlich. Scala for Backend Engineering & Functional Programming 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 2 von 4.
Wie lange dauert die Lektion „Transformationen“?
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 Scala for Backend Engineering & Functional Programming-Lektion Code schreiben und ausführen?
Ja. Jede Scala for Backend Engineering & Functional Programming-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.