Scala for Backend Engineering & Functional Programming · Lektion

Funktionale Operationen auf Collections

Beherrschen Sie gängige funktionale Operationen wie map, filter, fold und reduce zur Datentransformation.

Lektion 2 von 311 Schritte

Funktionale Operationen auf Collections ist eine kostenlose Scala for Backend Engineering & Functional Programming-Lektion auf CoddyKit. Dies ist Lektion 2 von 3. 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 3 Lektionen.

Funktionale Operationen: Warum sollte man sie verwenden?

Funktionale Operationen auf Collections helfen Ihnen dabei, Daten zu transformieren und zu kombinieren, ohne die ursprüngliche Collection zu verändern. Dieser Ansatz fördert die Unveränderlichkeit und macht Ihren Code leichter lesbar und testbar.

Wir sehen uns wichtige Operationen wie map, filter, reduce und fold an.

Mit `map` transformieren

Die Operation map wendet eine Funktion auf jedes Element einer Collection an und gibt eine neue Collection mit den transformierten Ergebnissen zurück. Die ursprüngliche Collection bleibt unverändert.

Führen Sie dieses Beispiel aus:

object Main {
  def main(args: Array[String]): Unit = {
    val numbers = List(1, 2, 3, 4)
    val doubled = numbers.map(n => n * 2)
    println(s"Original: $numbers")
    println(s"Doubled: $doubled")
  }
}

`map` mit unterschiedlichen Typen

map ist sehr flexibel! Sie können Elemente in einen völlig anderen Typ umwandeln. Hier konvertieren wir Zahlen in Zeichenketten oder ermitteln die Länge von Zeichenketten.

Beachten Sie, dass das Ergebnis eine List[Int] ist, obwohl die Eingabe eine List[String] war.

object Main {
  def main(args: Array[String]): Unit = {
    val names = List("Alice", "Bob", "Charlie")
    val lengths = names.map(name => name.length)
    println(s"Names: $names")
    println(s"Lengths: $lengths")
  }
}

Mit `filter` auswählen

Die Operation filter erstellt eine neue Collection, die nur die Elemente enthält, die eine bestimmte Bedingung erfüllen (eine Prädikatsfunktion). Unerwünschte Elemente werden dabei herausgefiltert.

Ermitteln wir die geraden Zahlen:

object Main {
  def main(args: Array[String]): Unit = {
    val numbers = List(1, 2, 3, 4, 5, 6)
    val evens = numbers.filter(n => n % 2 == 0)
    println(s"Original: $numbers")
    println(s"Evens: $evens")
  }
}

Weitere Beispiele für `filter`

Sie können jeden booleschen Ausdruck als Filterbedingung verwenden. Filtern wir eine Liste von Wörtern, sodass nur Wörter mit mehr als 4 Zeichen erhalten bleiben.

object Main {
  def main(args: Array[String]): Unit = {
    val words = List("apple", "cat", "banana", "dog", "elephant")
    val longWords = words.filter(w => w.length > 4)
    println(s"Words: $words")
    println(s"Long words: $longWords")
  }
}

Mit `reduce` kombinieren

Die Operation reduce kombiniert alle Elemente einer Collection zu einem einzigen Ergebnis. Sie nimmt eine binäre Operation (eine Funktion, die zwei Argumente entgegennimmt und eines zurückgibt) und wendet sie schrittweise an.

Hier summieren wir alle Elemente:

object Main {
  def main(args: Array[String]): Unit = {
    val numbers = List(1, 2, 3, 4)
    val sum = numbers.reduce((a, b) => a + b)
    println(s"Numbers: $numbers")
    println(s"Sum: $sum")
  }
}

`reduce` für Produkt und Maximum

Mit reduce können Sie verschiedene Aggregationen durchführen. Wir können das Produkt von Zahlen berechnen oder den Maximalwert ermitteln.

Hinweis: Bei einer leeren Collection löst reduce einen Fehler aus.

object Main {
  def main(args: Array[String]): Unit = {
    val numbers = List(1, 5, 2, 8)
    val product = numbers.reduce((a, b) => a * b)
    val maxNum = numbers.reduce((a, b) => if (a > b) a else b)
    println(s"Numbers: $numbers")
    println(s"Product: $product")
    println(s"Max: $maxNum")
  }
}

`fold`: Die Macht des Anfangswerts

fold ähnelt reduce, unterscheidet sich aber in einem wichtigen Punkt: Es nimmt einen Anfangswert entgegen, der auch als „Akkumulator“ bezeichnet wird. Dadurch ist es für leere Collections sicher und ermöglicht unterschiedliche Ergebnistypen.

Summieren wir Zahlen, beginnend bei 10:

object Main {
  def main(args: Array[String]): Unit = {
    val numbers = List(1, 2, 3)
    // foldLeft(initialValue)(operation)
    val sumWithInitial = numbers.foldLeft(10)((acc, n) => acc + n)
    println(s"Numbers: $numbers")
    println(s"Sum (starting from 10): $sumWithInitial")
  }
}

Richtung: `foldLeft` und `foldRight`

Scala bietet foldLeft und foldRight. Sie unterscheiden sich in der Reihenfolge, in der die Elemente verarbeitet werden, und darin, wie der Akkumulator weitergegeben wird.

foldLeft(initial)(op): Verarbeitet die Elemente von links nach rechts.
foldRight(initial)(op): Verarbeitet die Elemente von rechts nach links.

Bei Operationen wie der Verkettung von Zeichenketten ist die Richtung wichtig!

object Main {
  def main(args: Array[String]): Unit = {
    val chars = List('a', 'b', 'c')
    val leftFold = chars.foldLeft("")((acc, c) => acc + c)
    val rightFold = chars.foldRight("")((c, acc) => acc + c)
    println(s"Chars: $chars")
    println(s"foldLeft: $leftFold") // Output: abc
    println(s"foldRight: $rightFold") // Output: abc (due to string append order)

    // Example where order matters: (acc, char) => char + acc
    val rightFoldReversed = chars.foldRight("")((c, acc) => c + acc)
    println(s"foldRight (char + acc): $rightFoldReversed") // Output: abc

    // A common example where order matters is for operations like subtraction or division, but string concatenation also shows it.
  }
}

Test zu funktionalen Operationen

Betrachten Sie den folgenden Scala-Codeausschnitt:

val data = List(10, 20, 30, 40)
val result1 = data.map(x => x / 10)
val result2 = data.filter(x => x > 25)
val result3 = data.reduce((a, b) => a + b)

Welche der folgenden Aussagen über die Ergebnisse sind RICHTIG?

Beantworte es in der interaktiven Lektion

Zusammenfassung: Die Macht funktionaler Operationen

Sie beherrschen nun die wichtigsten funktionalen Operationen!

map transformiert jedes Element.
filter wählt Elemente anhand einer Bedingung aus.
reduce kombiniert Elemente zu einem einzigen Ergebnis (erfordert eine nicht leere Collection).
fold kombiniert Elemente mit einem Anfangswert (sicher für leere Collections).

Diese Operationen sind entscheidend, um prägnanten, unveränderlichen und leistungsfähigen Scala-Code zu schreiben. Als Nächstes sehen wir uns die robuste Fehlerbehandlung mit Option, Try und Either an.

Kostenlos starten

Lerne Scala mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse: 39
Lektionen: 143

Kostenlos lernen Den vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „Funktionale Operationen auf Collections“ kostenlos?

Ja — der vollständige Text von „Funktionale Operationen auf Collections“ 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 3 Lektionen.

Was lerne ich in „Funktionale Operationen auf Collections“?

Beherrschen Sie gängige funktionale Operationen wie map, filter, fold und reduce zur Datentransformation. 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 3.

Wie lange dauert die Lektion „Funktionale Operationen auf Collections“?

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.

Alle Lektionen in diesem Kurs

Vertiefung zu unveränderlichen Collections
Funktionale Operationen auf Collections
Option, Try und Either für Fehler

← Zurück zu Scala for Backend Engineering & Functional Programming