Java Streams Advanced – Gatherers, Spliterators & Co.

In diesem zweitägigen Aufbaukurs lernst du, wie du die Java Stream API in der Tiefe verstehst und fortgeschrittene Techniken wie Custom Collectors, Gatherers und Spliterators gezielt einsetzt.

Am ersten Tag des Kurses stehen fortgeschrittene Collectors und Aggregationstechniken im Fokus. Du lernst, wie reduce(), groupingBy() und Downstream Collectors funktionieren – und entwickelst eigene Collector-Implementierungen, abgestimmt auf deine konkreten Anforderungen. Dabei bekommst du ein Gespür dafür, wann und wie Parallelisierung sinnvoll ist – und welche Fallstricke du besser vermeidest.

Am zweiten Tag tauchen wir ein in die Welt der Spliterators und der neuen Gatherers-API ab Java 22. Du erfährst, wie du mit Custom Spliterators große Datenmengen effizient aufteilst und Streams präzise steuerst. Mit Stream Gatherers baust du leistungsfähige Streaming-Operationen mit Zustand – wie Sliding Windows und Folding.

Zahlreiche Übungen und ein abschließender Refactoring-Workshop sorgen dafür, dass du das Gelernte direkt anwenden kannst – mit echtem Mehrwert für deine Projekte.

Inhouse-Schulung anfragen »

👉 Du bist mit Streams noch nicht so vertraut? Dann starte mit Java Streams Basics – Praxis-Grundlagen für EinsteigerInnen.

👉 Du möchtest das komplette Spektrum der Stream API in einem Kurs abdecken? Dann ist der Kombikurs Java Streams Basics + Advanced die passende Wahl.

Der Kurs richtet sich an erfahrene Java-EntwicklerInnen, die bereits mit Streams gearbeitet haben und jetzt tiefer in fortgeschrittene Themen einsteigen möchten.

Wenn du regelmäßig mit Streams arbeitest, deinen Code weiter verbessern willst – oder neugierig auf Custom Collectors, Gatherers oder Spliterators bist – bist du hier genau richtig.

Die Themen bauen systematisch aufeinander auf. Wir wechseln zwischen fortgeschrittener Theorie, konkreten Anwendungsfällen und praxisorientierten Übungen – immer mit Blick auf Performance, Lesbarkeit und Wartbarkeit.

Advanced Collectors und Reduce Operations

• reduce() für Aggregationen: Konzepte und praktische Anwendung
• peek() für Debugging: Wann sinnvoll, wann nicht
• Grouping: groupingBy(), partitioningBy()
• Downstream Collectors: counting(), summingInt(), averagingDouble()
• Nested Grouping und komplexe Aggregationen
• joining() für String-Operationen
• Praktische Übungen: Komplexe Datenanalyse mit Collectors

Custom Collectors entwickeln

• Collector Interface verstehen: supplier(), accumulator(), combiner(), finisher()
• Characteristics: CONCURRENT, IDENTITY_FINISH, UNORDERED
• Einfache Custom Collectors implementieren
• Komplexere Scenarios: Custom Object Collection
• Praktische Übungen: Eigene Collectors schreiben

Stream Performance und Spliterator Grundlagen

• Wann Streams verwenden vs. traditionelle Schleifen
• Performance-Fallen: Boxing/Unboxing, zu lange Pipelines
• Parallel Streams: Wann sinnvoll, Common Fork/Join Pool
• Memory-Effizienz und große Datenmengen
• Spliterator verstehen: Was ist ein Spliterator und seine Rolle
• Spliterator Characteristics: ORDERED, SIZED, SUBSIZED, CONCURRENT, etc.
• Wie Characteristics die Stream-Performance beeinflussen

Legacy Code Refactoring Workshop

• Gemeinsame Refactoring-Session: Schleifen zu Streams
• Identifikation geeigneter Refactoring-Kandidaten
• Schritt-für-Schritt Transformation von Legacy Code
• Performance-Vergleiche: Vorher/Nachher
• Code-Readability vs. Performance Trade-offs
• Wann Refactoring sinnvoll ist und wann nicht
• Praktische Übungen: Verschiedene Legacy-Szenarien

Fortgeschrittene Stream-Patterns und Custom Spliterators

• Conditional Operations mit Optional
• Error Handling in Streams
• Custom Spliterator implementieren: Eigene Datenstrukturen für Streams
• Spliterator Patterns: tryAdvance(), trySplit(), estimateSize()
• Parallelisierung optimieren durch custom Spliterators
• Stream von Files: Lines, Directory Walking
• Infinite Streams: generate(), iterate()
• Praktische Übungen: Custom Spliterator für spezielle Datenstrukturen

Stream Gatherers (Java 22+)

• Was sind Stream Gatherers und warum wurden sie eingeführt
• Gatherer Interface verstehen: integrator(), combiner(), finisher()
• Built-in Gatherers: fold(), scan(), windowFixed(), windowSliding()
• Custom Gatherers implementieren
• State Management in Gatherers
• Praktische Übungen: Eigene Gatherers für spezielle Use Cases

Integration und Architecture Patterns

• Streams in Repository Pattern
• Functional Programming Principles mit Streams
• Stream-basierte APIs designen
• Migration Strategies: Legacy Code zu Streams
• Anti-Patterns und Debugging: Typische Fehler vermeiden
• Testing von Stream-Code

Workshop und Problemlösung

• Komplexes Praxisprojekt: Ende-zu-Ende Stream-Pipeline
• Code Review Session: Teilnehmer-Code analysieren
• Performance-Optimierung an realen Beispielen
• Q&A und individuelle Problemstellungen
• Best Practices Zusammenfassung