Unendliche Streams
Modellieren Sie endlose Daten sicher.
Unendliche Streams ist eine kostenlose Scala for Backend Engineering & Functional Programming-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 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.
Unendlichkeit, sicher umgesetzt
Eine LazyList kann eine unendliche Sequenz beschreiben, weil ihr Ende erst berechnet wird, wenn es angefordert wird. Sie materialisieren immer nur das Präfix, das Sie verbrauchen.
So können Sie natürliche Zahlen, Primzahlen oder Sensormesswerte modellieren, ohne sie im Voraus zu begrenzen.
Alle natürlichen Zahlen
LazyList.from(1) ist die unendliche Sequenz 1, 2, 3, ... Sie können jedes endliche Präfix abrufen.
Die Auswertung der gesamten Sequenz würde niemals enden. Begrenzen Sie sie daher immer mit take oder stoppen Sie sie mit einem Prädikat.
object Demo extends App {
val nats = LazyList.from(1)
println(nats.take(5).toList)
}from mit einem Schritt
LazyList.from(start, step) zählt in einem bestimmten Intervall weiter. Verwenden Sie es für gerade Zahlen, Taktimpulse oder beliebige arithmetische Folgen.
Die Sequenz ist unendlich, aber jeder Aufruf von take erzwingt nur so viel, wie Sie anfordern.
object Demo extends App {
val evens = LazyList.from(0, 2)
println(evens.take(5).toList)
}Selbstreferenzielle Datenströme
Ein bekannter Trick besteht darin, eine LazyList mithilfe ihrer selbst zu definieren. Die Fibonacci-Folge lässt sich ausdrücken, indem Sie den Datenstrom mit seinem eigenen Ende zusammenführen.
Das funktioniert nur, weil das Ende bis zum Abruf der jeweiligen Zelle unausgewertet bleibt.
lazy val fibs: LazyList[Int] =
0 #:: 1 #:: fibs.zip(fibs.tail).map { case (a, b) => a + b }
// fibs(0)=0, fibs(1)=1, fibs(2)=1 ...Fibonacci ausführen
Erzwingen wir ein Präfix dieses selbstreferenziellen Fibonacci-Datenstroms.
Jedes neue Element wird aus früheren, bereits memoisierten Elementen berechnet. Dadurch bleibt die gesamte Berechnung effizient, während Sie weitere Werte abrufen.
object Demo extends App {
lazy val fibs: LazyList[Int] =
0 #:: 1 #:: fibs.zip(fibs.tail).map { case (a, b) => a + b }
println(fibs.take(10).toList)
}iterate für Sequenzen
LazyList.iterate erzeugt mithilfe einer Schritt-Funktion eine unendliche Sequenz. Potenzen, geometrisches Wachstum und Zustandsautomaten lassen sich damit natürlich ausdrücken.
Hier ist jedes Element für immer dreimal so groß wie das vorherige.
object Demo extends App {
val triples = LazyList.iterate(1)(_ * 3)
println(triples.take(6).toList)
}Ein Primzahlsieb
Unendliche Datenströme eignen sich hervorragend für das Sieb des Eratosthenes. Nehmen Sie eine Kopf-Primzahl, filtern Sie ihre Vielfachen aus dem Rest heraus und fahren Sie rekursiv fort.
Der Filter ist lazy, sodass die Primzahlen einzeln erzeugt werden, während Sie sie verbrauchen.
def sieve(s: LazyList[Int]): LazyList[Int] =
s.head #:: sieve(s.tail.filter(_ % s.head != 0))
val primes = sieve(LazyList.from(2))Das Sieb ausführen
Rufen wir nun die ersten zehn Primzahlen aus diesem unendlichen Sieb ab.
Vom zugrunde liegenden Zahlenstrom wird nur so viel erzwungen, wie nötig ist, um zehn Primzahlen zu liefern. Das veranschaulicht die bedarfsgesteuerte Berechnung.
object Demo extends App {
def sieve(s: LazyList[Int]): LazyList[Int] =
s.head #:: sieve(s.tail.filter(_ % s.head != 0))
val primes = sieve(LazyList.from(2))
println(primes.take(10).toList)
}Niemals die gesamte Sequenz erzwingen
Methoden, die die gesamte Sequenz benötigen, etwa length, toList auf einem unbegrenzten Datenstrom oder foreach ohne Abbruch, bleiben bei einer unendlichen LazyList hängen.
Begrenzen Sie die Sequenz immer zuerst mit take, takeWhile oder find.
// DON'T: LazyList.from(1).toList // hangs forever
val ok = LazyList.from(1).take(3).toListDie Falle des festgehaltenen Kopfes
Wenn ein val den Kopf einer unendlichen memoisierten LazyList festhält und Sie weit durch sie hindurchlaufen, bleiben alle erzwungenen Zellen aktiv und verursachen ein Speicherleck.
Bei langen Durchläufen sollten Sie die Elemente über eine Methode verbrauchen, ohne den Kopf zu binden, oder einen Iterator verwenden.
Warum unendliche Datenströme wichtig sind
Unendliche Datenströme trennen Erzeugung und Verbrauch. Der Produzent beschreibt eine endlose Regel; der Verbraucher entscheidet, wie viel materialisiert wird.
Das ist ein leistungsfähiges funktionales Muster für Pipelines, Simulationen und lazy Datenquellen.
Schnelltest
Testen Sie Ihr Verständnis unendlicher LazyLists.
Zusammenfassung
Unendliche LazyLists funktionieren, weil der Tail bedarfsgesteuert ist: from, iterate, die selbstreferenzielle fibs-Liste und das Primzahlsieb erzeugen endlos Werte, realisieren aber nur, was Sie konsumieren.
Vermeiden Sie Operationen auf der gesamten Sequenz und das Festhalten am Kopf. Als Nächstes lernen Sie, wie Sie LazyLists verzögert nehmen und filtern.
Häufig gestellte Fragen
Ist die Lektion „Unendliche Streams“ kostenlos?
Ja — der vollständige Text von „Unendliche Streams“ 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 „Unendliche Streams“?
Modellieren Sie endlose Daten sicher. 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 3 von 4.
Wie lange dauert die Lektion „Unendliche Streams“?
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
- Lazy Evaluation erklärt
- Eine LazyList erstellen
- Unendliche Streams
- Lazy entnehmen und filtern