« Alle Java-Schulungen

Kombikurs Java Streams Basics + Advanced

Dauer: 3 Tage
Format: virtuell oder vor Ort

Beschreibung

Dieser dreitägige Kombikurs vereint die Inhalte zweier Einzeltrainings – Java Streams Basic und Java Streams Advanced – und vermittelt dir ein praxisnahes und tiefgehendes Verständnis der Java Stream API: von den Grundlagen über Best Practices bis hin zu fortgeschrittenen Techniken wie Custom Collectors und Stream Gatherers.

Am ersten Tag lernst du die funktionalen Grundlagen und den Aufbau von Stream-Pipelines kennen:

  • Rolle von Intermediate- und Terminal-Operations
  • Unterschied zu Collections
  • Vorteile von Lazy Evaluation
  • Stream-Erstellung mit Collections, Arrays, Files und Ranges

All das setzt du direkt in praktischen Übungen um – die perfekte Basis für die fortgeschrittenen Themen an Tag zwei und drei.

An Tag zwei und drei geht es um Effizienz, Erweiterbarkeit und moderne Techniken:

  • Eigene Collectors entwickeln (inkl. Characteristics & Finisher)
  • Stream-Pipelines analysieren und optimieren
  • Custom Spliterators schreiben – und ihre Performance-Vorteile verstehen
  • Infinite Streams, Directory Walking & File-Streams
  • Stream Gatherers API (ab Java 22): Built-ins einsetzen, eigene Gatherers schreiben, State verwalten

Dabei entwickelst du ein tiefes Verständnis für das Innenleben der Streams – und kannst sicher entscheiden, wann und wie du Streams sinnvoll einsetzt – und wann du bewusst darauf verzichtest.

Der Kurs endet mit einem umfangreichen Abschlussprojekt, in dem du ein reales Datenverarbeitungsszenario mit Streams modellierst – von der Anforderung über das Stream-Design bis zur performanten Lösung. Wir analysieren gemeinsam eure Ergebnisse und diskutieren Best Practices für produktionsreifen Stream-Code.eam.

Inhouse-Schulung anfragen »

👉 Du suchst nur den Einstieg? Dann wirf einen Blick auf Java Streams Basics – Praxis-Grundlagen für EinsteigerInnen.

👉 Oder du willst nur die fortgeschrittenen Themen? Dann passt Java Streams Advanced – Gatherers, Spliterators & Co. besser zu dir.

Zielgruppe

Der Kurs richtet sich an Java-EntwicklerInnen, die von Grund auf lernen möchten, wie sie die Streams API effizient und elegant einsetzen – und direkt tiefer einsteigen wollen: mit Fokus auf Performance, Erweiterbarkeit und modernen Features wie Gatherers oder Custom Spliterators.

Ideal für alle, die sich in kurzer Zeit ein umfassendes Wissen zu Java Streams aneignen wollen – etwa bei einem Technologie-Upgrade, Relaunch oder Refactoring-Vorhaben.

Kursinfos

Dauer: 3 Tage
Termin nach Wunsch
Exklusiv für dein Team
In euren Räumlichkeiten oder virtuell
Kursinhalt auf Wunsch anpassbar
Sprache: deutsch oder englisch
Teilnahmezertifikat

Preise

Inhouse vor Ort:  6.230,– EUR
zzgl. Reisekosten des Trainers
Virtuell:  5.120,– EUR
Die Preise verstehen sich ohne individuelle Anpassungen und zzgl. der am Ort der Schulung anwendbaren Umsatzsteuer.

Agenda

Der Kurs kombiniert die Inhalte der beiden Einzeltrainings. Wir starten mit den Grundlagen und steigen danach schrittweise in fortgeschrittene Techniken ein – mit vielen Beispielen, Übungen und Raum für eure Fragen.

Tag 1: Streams Basics

Funktionale Programmierung in Java:

  • Lambda-Ausdrücke: Syntax, Typen und Verwendung
  • Funktionale Interfaces (Consumer, Supplier, Function, Predicate, etc.)
  • Methodenreferenzen: Static, Instance, Constructor References
  • Praktische Übungen: Lambda-Ausdrücke vs. anonyme Klassen

Stream-Grundlagen:

  • Was ist ein Stream? Konzeptuelle Unterschiede zu Collections
  • Stream-Pipeline Anatomie: Source → Intermediate Operations → Terminal Operations
  • Lazy Evaluation und ihre Auswirkungen
  • Stream-Erstellung: von Collections, Arrays, Files, Ranges
  • Primitive Streams: IntStream, LongStream, DoubleStream
  • Praktische Übungen: Erste Stream-Pipelines mit primitiven Streams

Intermediate Operations Deep Dive:

  • Transformationen mit map(), flatMap(), filter()
  • Auswahl und Sortierung: distinct(), sorted(), limit(), skip()
  • Debugging mit peek() – richtig eingesetzt
  • Chaining von Operations und Performance-Aspekte
  • Praktische Übungen: Komplexere Datenverarbeitung

Terminal Operations:

  • collect() – der vielseitigste Terminal Operator
  • Eingebaute Collectors: toList(), toSet(), toMap()
  • forEach(), forEachOrdered()
  • reduce() für Aggregationen
  • find-Operationen: findFirst(), findAny()
  • Matching-Operationen: allMatch(), anyMatch(), noneMatch()
  • Praktische Übungen: Terminal Operations mit Standard-Collectors

Tage 2 und 3: Streams Advanced

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
Ausblick:
  • Structured Concurrency
  • Scoped Values
  • Vector API
  • Foreign Function & Memory API
  • Unnamed Patterns and Variables
  • Comptact Classes and Instance Main Methods

Inhouse-Training anfragen

Anfrage Schulung Spezifischer Kurs (#30)

Euer Trainer: Sven Woltmann

Sven Woltmann

Ich bin Java-Experte mit über 20 Jahren Erfahrung – als Entwickler, Architekt, CTO, Performance-Coach und Trainer.

Ich habe bei Unternehmen wie 1&1, IONOS und ICE Services komplexe Enterprise-Systeme mit Milliarden-Datenmengen konzipiert, monolithische Altanwendungen modernisiert und Teams geholfen, robuste, wartbare und performante Java-Anwendungen zu entwickeln.

Mit HappyCoders.eu habe ich einen der meistgelesenen Java-Blogs im deutschsprachigen Raum aufgebaut. Ich halte Vorträge auf Konferenzen und Java User Groups und erhalte immer wieder das Feedback, dass ich komplexe technische Konzepte verständlich erklären kann.

Was ihr in meinen Schulungen bekommt:

  • Langjährige Erfahrung: Tiefes Java-Wissen kombiniert mit echter Projektpraxis
  • Praxisbezug: Viele Hands-On-Übungen, inspiriert von realen Projektsituationen
  • Erfahrungsaustausch: Raum für eure Fragen, Diskussionen und konkrete Herausforderungen
  • Fokus auf euer Team: Inhalte können flexibel auf eure Ziele abgestimmt werden

Ich vermittle nicht nur Features, sondern zeige euch, wie ihr mit dem richtigen Java-Verständnis langfristig bessere Software entwickelt.

Mehr über mich »

Format & Voraussetzungen

Relevante weitere Trainings