You already know streams – but when are parallel streams actually faster, and when do they slow you down? How do you build custom collectors that combine cleanly with groupingBy()? And what do Stream Gatherers (Java 24+) make possible that simply wasn’t possible before?
In two days, this course takes your team to the next level of the Java Streams API – clearly explained and directly applicable.
💡 New to Java Streams? → Java Streams Basics Training
✅ Already familiar with streams, ready for more? → You’re in the right place.
In this two-day advanced course, you’ll learn how to gain a deep understanding of the Java Stream API and how to apply advanced techniques like custom collectors, gatherers, and spliterators effectively.
Day one focuses on advanced collectors and aggregation techniques. You’ll explore how reduce(), groupingBy(), and downstream collectors work – and how to implement your own custom collectors tailored to your specific requirements. You’ll also develop an intuition for when parallel streams makes sense – and where to avoid common pitfalls.
On day two, we dive into the world of spliterators and the new Gatherers API finalized in Java 24. You’ll learn how to efficiently partition large datasets with custom spliterators, and how to build powerful streaming operations with stream gatherers, including use cases like sliding windows and folding.
Hands-on exercises and a final refactoring workshop ensure that you can apply your knowledge directly – with real value for your projects.
👉 Want the full spectrum of the Stream API in one go? Then the Combined Training Java Streams Basics + Advanced is the right fit for you.
👉 Is your team still working with Java 17 or 21? Then our Java 25 training might also be interesting for you.
This course is for experienced Java developers who have already worked with Streams and now want to explore more advanced topics.
If you use Streams regularly, want to improve your code – or are curious about custom Collectors, Gatherers, or Spliterators – this course is for you.
Topics are structured progressively. We alternate between advanced theory, practical use cases, and hands-on exercises – always focused on performance, readability, and maintainability.
Advanced Collectors and Reduce Operations:
reduce(): concepts and practical usepeek(): when it’s helpful and when notgroupingBy(), partitioningBy()counting(), summingInt(), averagingDouble()joining()Building Custom Collectors:
Collector interface: supplier(), accumulator(), combiner(), finisher()CONCURRENT, IDENTITY_FINISH, UNORDEREDStream Performance and Spliterator Basics:
ORDERED, SIZED, SUBSIZED, CONCURRENT, etc.Legacy Code Refactoring Workshop:
Advanced Stream Patterns and Custom Spliterators:
OptionaltryAdvance(), trySplit(), estimateSize()generate(), iterate()Stream Gatherers (since Java 22, finalized in Java 24):
Gatherer interface: integrator(), combiner(), finisher()fold(), scan(), windowFixed(), windowSliding()Integration and Architecture Patterns:
Workshop and Problem Solving:
The agenda isn’t set in stone: we can align the focus, date, and format with your team.
Request now – no obligationI’ve been working with Java for 30 years – as a developer, CTO, trainer, author, and speaker.
In that time, I’ve helped companies modernize complex Java systems, write performant code, and develop their teams sustainably.
With HappyCoders.eu, I’ve built one of the most widely read Java blogs in the German-speaking world, and I regularly speak at conferences and user groups.
My goal: to teach complex topics in a way that is understandable, practical, and immediately applicable.
Sven Woltmann of HappyCoders visited us to test and understand the new features around Java 25 together.
For two days, we worked intensively on Unnamed Variables & Patterns, Stream Gatherers, Scoped Values, the Foreign Function & Memory API, and performance topics such as virtual threads without pinning.
A big thank you to Sven for the excellent preparation, the clear didactics, and the deep technical expertise. That was a training exactly to our taste.
Content and presentation nearly flawless. I enjoyed listening throughout, learned new things, and had fun doing it.
Your confidence in answering questions along the way was impressive.
Anyone who understands Java can easily follow this trainer. The exercises are well thought out and focused on the essentials.
A good, in-depth overview of all relevant Java features since Java 8, and the opportunity to try all of these features out yourself.
The overall package was very coherent and always tailored to us.
Very practical and good exercise examples.
Quick to respond to questions – a very flexible trainer.
Very good repo with explanations + exercises in one place.
Pace + depth: top-notch.
A very pleasant mix of theory and practice.
A complex topic broken down superbly.
All the important news from Java 9–25 was well explained.
The mix of knowledge, likability, and content was very pleasant.
This training can only be booked for teams. If you’d like to attend as an individual, I offer two courses (in German) through ppedv:
Both are possible: I can come to your company for an on-site training – anywhere in Germany, Austria, and Switzerland – or we run the training online, usually via Zoom.
I recommend a maximum of 12 participants per training – that way I can give everyone individual attention. There is no minimum: I charge per training, not per person.
The easiest way is the request form or an email to training@happycoders.eu. Right after submitting, you can book a video call via Calendly, where we discuss the details. You’ll then receive a concrete offer from me.
The course assumes that you already have practical experience with the Stream API – you should be familiar with filter(), map(), collect(), and the common standard collectors.
If you’ve never worked with streams before, you’re better off in the Basics course.
All participants need an up-to-date IDE with at least Java 24 – I use IntelliJ IDEA myself. Java 24 or later should also be installed in the terminal, as we’ll run some of the exercises there.
A training day consists of four 90-minute modules – six hours of net training time in total. Each module alternates between theory and practice two to three times, so you apply what you’ve just learned directly to code. There’s a short break between the first and second and between the third and fourth module, and a longer lunch break between modules two and three. We align the exact schedule with your working hours – that’s flexible.
About half theory, half practice: a short theory phase is followed directly by applying it to code – with examples from real projects. Listening alone doesn’t help much; the knowledge has to be used immediately for it to stick.
Yes – shortening topics, weighting them differently, changing the order, or combining content from different courses: I’m happy to adapt the agenda to your team. Since that means reworking the training materials, it involves extra effort – I’ll prepare an individual offer for you.
We usually use Zoom. If you prefer your own platform – for example, Microsoft Teams or Google Meet – I’m happy to work with that. Just let me know in advance.
Yes. Before the training, you’ll receive the exercises as a Git repository so you can get started right away. After the training, you’ll also receive the slides – including all solutions to the exercises.
Yes. All participants receive a certificate of attendance after the training.
Travel expenses are charged as a flat rate – depending on the training location and the number of overnight stays required. The exact amount is part of the individual offer I’ll send you.
Yes. For multiple booked trainings or follow-up bookings, I can offer a volume discount. We’ll discuss this in the video call, and I’ll include it in the offer.
Just write to me – I usually reply within one business day.
Or book a free video call right away, and we’ll discuss everything important.