Sequences in Kotlin – große Datenmengen faul verarbeiten und früh aufhören

map, filter und Co. sind bequem – aber jede dieser Funktionen baut eine komplette neue Liste. Bei kleinen Daten egal. Bei einer langen Kette über viele Einträge produzierst du Zwischenlisten, die du nie brauchst. asSequence() schaltet auf faule (lazy) Verarbeitung um: Jedes Element wandert einzeln durch die ganze Kette, und die Arbeit startet erst, wenn du das Ergebnis wirklich abholst.

Eager vs. lazy

// Eager (Standard): baut bei jedem Schritt eine ganze Zwischenliste
val eager = (1..1_000_000)
    .map { it * 2 }          // Liste mit 1.000.000 Einträgen
    .filter { it % 3 == 0 }  // noch eine große Liste
    .take(5)                 // erst JETZT wird gekürzt – die Arbeit war längst getan

// Lazy: Element für Element, und die Kette stoppt, sobald 5 Treffer feststehen
val lazy = (1..1_000_000)
    .asSequence()
    .map { it * 2 }
    .filter { it % 3 == 0 }
    .take(5)
    .toList()   // erst hier läuft die Kette – nur so weit wie nötig
// [6, 12, 18, 24, 30]

Beide liefern dasselbe Ergebnis. Die eager-Variante rechnet aber eine Million Verdopplungen aus, obwohl sie am Ende nur fünf Zahlen behält. Die Sequence hört nach knapp einem Dutzend Elementen auf.

Der eigentliche Trick: früh aufhören

Der größte Gewinn kommt, wenn eine teure Operation nur bis zum ersten Treffer laufen soll:

val ersterPassende = namen.asSequence()
    .map(::teuerNormalisieren)          // wird NUR bis zum Treffer aufgerufen
    .firstOrNull { it.startsWith("A") } // stoppt beim ersten "A…"

Ohne asSequence() würde teuerNormalisieren auf alle Namen angewendet, bevor firstOrNull überhaupt guckt. Mit Sequence wird genau bis zum ersten Treffer gerechnet – und keinen Schritt weiter.

Endlose Folgen ohne Endlosschleife

generateSequence erzeugt eine Folge, die theoretisch nie endet – aber nur so viel produziert, wie du dir nimmst:

val zweierPotenzen = generateSequence(1) { it * 2 }
    .take(10)
    .toList()   // [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]

Praktisch etwa, um paginiert Daten nachzuladen (generateSequence(erstePage) { ladeNächste(it) }) oder Fibonacci-artige Reihen zu bauen – ohne von Hand eine Abbruchbedingung in eine while-Schleife zu frickeln.

Wann du es lieber lässt

Sequences sind kein Gratis-Turbo. Für kleine Listen (ein paar Dutzend Einträge) ist die normale, eager Variante einfacher zu lesen und sogar schneller – der Sequence-Aufbau hat einen kleinen Overhead. Faustregel: asSequence() lohnt sich bei großen Datenmengen mit mehreren verketteten Schritten oder wenn du früh abbrichst (first, take, any). Sonst bleib bei map/filter.

In meinen Android-Apps nutze ich das gern beim Filtern großer, lokal geladener Listen, bevor sie in eine LazyColumn gehen – ein Durchgang statt drei Zwischenlisten. Wenn du eine App hast, die bei großen Datenmengen ruckelt, schau ich mir das gern an: bymw.de.

Quellen

• Sequences – Kotlin-Dokumentation
• generateSequence – Kotlin API-Referenz