HappyCoders

Kombikurs Java Streams: Basics + Advanced

Wer Java Streams wirklich beherrschen will, sollte Basics und Advanced nicht auf zwei separate Trainingsblöcke verteilen. Der Wissensaufbau funktioniert besser am Stück: Was euer Team an Tag eins mit Stream-Pipelines, flatMap() und Collectors aufbaut, wird an Tag zwei und drei sofort weitergedacht – mit Custom Spliterators, groupingBy() und den neuen Stream Gatherers.

In drei Tagen bringt dieser Kurs euer Team auf das volle Niveau der Java Streams API – verständlich erklärt, direkt anwendbar und günstiger als zwei Einzelbuchungen.

Jetzt unverbindlich anfragen
3 Tage
Individueller Termin
Vor Ort oder Online
Deutsch / Englisch
Kursinhalt konfigurierbar
Teilnahme- zertifikat

Was ihr in dieser Schulung lernt

Dieser dreitägige Kombikurs vereint die Inhalte zweier Einzeltrainings – Java Streams Basics und Java Streams Advanced – und vermittelt euch 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.

Ihr könnt Java Streams auch in zwei getrennten Trainings lernen – aber das Kombipaket ist effizienter: drei kompakte Tage statt vier, ein nahtloser Übergang von Basics zu Advanced, und ein Lernbogen, der ohne Unterbrechung aufeinander aufbaut.

Am ersten Tag lernt ihr 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 ihr 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, finalisiert in Java 24): Built-ins einsetzen, eigene Gatherers schreiben, State verwalten

Dabei entwickelt ihr ein tiefes Verständnis für das Innenleben der Streams – und könnt sicher entscheiden, wann und wie ihr Streams sinnvoll einsetzt – und wann ihr bewusst darauf verzichtet.

Der Kurs endet mit einem umfangreichen Abschlussprojekt, in dem ihr ein reales Datenverarbeitungsszenario mit Streams modelliert – 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.

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

👉 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-Entwickler:innen, 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.

Agenda

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() – Stream to Map leicht gemacht
  • forEach(), forEachOrdered()
  • reduce() für Aggregationen
  • find-Operationen: findFirst(), findAny() – Rückgabetyp Optional verstehen und richtig verwenden
  • 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 (ab Java 22, finalisiert in Java 24):

  • 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

Ist das das Training, das euer Team weiterbringt?

Jetzt unverbindlich anfragen

Warum mit mir lernen?

Ich arbeite seit über 20 Jahren als Entwickler, CTO, Trainer, Autor und Speaker mit Java.

In dieser Zeit habe ich Unternehmen geholfen, komplexe Java-Systeme zu modernisieren, performanten Code zu schreiben und Teams nachhaltig weiterzuentwickeln.

Mit HappyCoders.eu habe ich einen der meistgelesenen Java-Blogs im deutschsprachigen Raum aufgebaut und halte regelmäßig Vorträge auf Konferenzen und User Groups.

Mein Ziel: komplexe Themen so vermitteln, dass sie verständlich, praxisnah und direkt anwendbar sind.

Bewertet mit 4,97 von 5 auf ProvenExpert

Mehr über mich

Noch Fragen?

Teilnahme & Buchung

Können Einzelpersonen das Training buchen?

Dieses Training ist ausschließlich für Teams buchbar. Wenn du als Einzelperson teilnehmen möchtest, biete ich zwei Kurse über ppedv an:

Wie viele Teilnehmer:innen sind möglich?

Ich empfehle maximal 12 Teilnehmer:innen pro Training. So kann ich alle individuell betreuen. Eine Mindestanzahl gibt es nicht – ich berechne pro Training, nicht pro Person.

Wie läuft die Buchung ab?

Am einfachsten über das Anfrageformular oder per E-Mail an schulung@happycoders.eu. Direkt nach dem Absenden kannst du über Calendly einen Video-Call buchen, in dem wir die Details besprechen. Danach bekommst du ein konkretes Angebot von mir.

Voraussetzungen

Welche Java-Vorkenntnisse werden vorausgesetzt?

Der Kurs setzt solide Java-Grundkenntnisse voraus – idealerweise mindestens zwei Jahre praktische Erfahrung. Da der erste Tag mit Lambda-Ausdrücken und funktionalen Interfaces beginnt, musst du diese Themen nicht vorab kennen. Erfahrung mit Collections und dem grundlegenden Java-Typsystem ist aber wichtig, damit wir direkt in die Stream-Pipeline-Konzepte einsteigen können.

Welche technischen Voraussetzungen brauchen wir?

Alle Teilnehmer:innen brauchen eine aktuelle IDE mit mindestens Java 24 – ich selbst verwende IntelliJ IDEA. Auch im Terminal sollte mindestens Java 24 installiert sein, da wir einige der Übungen im Terminal durchführen werden.

Ablauf & Inhalte

Wie läuft ein Trainingstag zeitlich ab?

Pro Tag gibt es 6 Stunden Netto-Training – in der Regel mit zwei kurzen Breaks und einer längeren Mittagspause dazwischen. Den genauen Zeitplan stimmen wir auf eure Arbeitszeiten ab – das lässt sich flexibel regeln.

Wie viel Zeit entfällt auf Theorie, wie viel auf Praxis?

Etwa zur Hälfte Theorie, zur Hälfte Praxis: Auf eine kurze Theoriephase folgt direkt die Anwendung am Code – mit Beispielen aus echten Projekten. Reines Zuhören hilft wenig; das Wissen muss sofort benutzt werden, damit es bleibt.

Können wir einzelne Themen aus der Agenda anpassen oder priorisieren?

Ja, das ist problemlos möglich. Themen streichen oder stärker gewichten – solange ich dafür die Trainingsunterlagen nicht umbauen muss, entstehen keine Extrakosten.

Wer umfangreichere Änderungen braucht – zum Beispiel Inhalte aus verschiedenen Kursen kombinieren oder ganz neue Themen aufnehmen – dem erstelle ich gerne ein individuelles Angebot.

Was genau bedeutet „Kursinhalt konfigurierbar“?

Innerhalb der bestehenden Agenda lässt sich die Gewichtung anpassen: Themen kürzen, Schwerpunkte setzen, Reihenfolge ändern. Das geht ohne Aufpreis.

Darüber hinaus sind auch tiefgreifendere Anpassungen möglich – etwa eine Kombination von Inhalten aus verschiedenen Kursen oder komplett neue Themenblöcke. Das ist mit Mehraufwand verbunden, daher erstelle ich dafür ein individuelles Angebot.

Format & Materialien

Welche Plattform nutzen wir beim virtuellen Training?

In der Regel verwenden wir Zoom. Wenn ihr eine eigene Plattform bevorzugt – zum Beispiel Microsoft Teams oder Google Meet – arbeite ich gerne damit. Sagt mir einfach vorab Bescheid.

Bekommen die Teilnehmer:innen Unterlagen zum Mitnehmen?

Ja. Vor dem Training erhaltet ihr die Übungsaufgaben als Git-Repository, damit ihr direkt loslegen könnt. Nach dem Training bekommt ihr außerdem die Folien – inklusive aller Lösungen zu den Übungsaufgaben.

Preise & Kosten

Was ist in den Reisekosten inbegriffen?

Die Reisekosten werden als Pauschale berechnet – abhängig vom Veranstaltungsort und der Anzahl der benötigten Übernachtungen. Die genaue Summe ist Bestandteil des individuellen Angebots, das ich dir zuschicke.

Gibt es Rabatte bei mehreren gebuchten Trainings?

Ja. Bei mehreren gebuchten Trainings oder Folgebuchungen kann ich einen Mengenrabatt anbieten. Das besprechen wir im Video-Call und ich halte das im Angebot fest.

Passt das für euer Team?

Schreib mir einfach – ich antworte in der Regel innerhalb von 24 Stunden.
Oder buch direkt einen kostenlosen Video-Call, in dem wir alles Wichtige besprechen.

Jetzt unverbindlich anfragen

Relevante weitere Trainings

Java Streams Basics – Praxis-Grundlagen für Einsteiger:innen

Lerne die Java Streams API von Grund auf: Wie funktionieren Stream-Pipelines? Was bedeutet Lazy Evaluation? Wann sind Streams wirklich hilfreich? Mit klaren Erklärungen, praxisnahen Übungen und Fokus auf funktionales Denken.

1 Tag Vor Ort / Online Deutsch / Englisch

Java Streams Advanced – Gatherers, Spliterators & Co.

Meistere die Stream API auf Expertenniveau: Entwickle eigene Collectors und Gatherers, arbeite mit Custom Spliterators und optimiere komplexe Datenflüsse – mit vielen praxisnahen Übungen und Fokus auf Performance.

2 Tage Vor Ort / Online Deutsch / Englisch