HappyCoders

Combined Training Java 17, 21 & 25 – Intensive: Records, Virtual Threads, Stream Gatherers & All New Features from Java 12 to 25

Many teams rely on LTS-to-LTS upgrades – and leave features on the table that would make their code more readable, more maintainable, and more performant. Records, Virtual Threads, Stream Gatherers: these language features and APIs have been production-ready for years – and are still used far too rarely.

In six days, this course covers all the important new features from Java 12 to 25 – in depth, hands-on, and with plenty of time for exercises, questions, and lasting transfer into your team.

Request now – no obligation
6 days
Individual date
On-site or online
German / English
Customizable content
Certificate of completion

What you’ll learn in this training

This 6-day intensive course covers all key features from Java 12 through 25 – with deep insights and a strong focus on practical relevance.

Start with Java 12–17: language features like Records, Switch Expressions, Pattern Matching for instanceof, Text Blocks, and Sealed Classes help make your code elegant and maintainable. Also included: API improvements, Garbage Collection, and performance upgrades.

Continue with major features from Java 18–21, such as Record Patterns, Pattern Matching for switch, Virtual Threads, and the Sequenced Collections API, plus API tweaks and runtime optimizations.

Finish with innovations from Java 22–25: Unnamed Variables & Patterns, Stream Gatherers, Scoped Values, Markdown Documentation Comments, and the powerful Foreign Function & Memory API. Performance topics include Compact Object Headers, Ahead-of-Time Class Loading, and more.

The training is interactive and hands-on: short theory phases are followed directly by application in code – with examples from real-world projects. You’ll work together on concrete scenarios, discuss solutions, and anchor the knowledge sustainably in your team.

Apply your skills through hands-on labs and gain a solid understanding of how to use the new features productively.

You’ll also get a sneak peek into upcoming developments like Structured Concurrency, Stable Values, Primitive Types in Patterns, and the Vector API.

For a complete overview of all features, see my Java 17 features article, the Java 21 features article, and the Java 25 features article.

Target audience

This course is for developers who want a complete update from Java 12 to 25 – clear, practical, and with space for individual questions.

Whether you’re upgrading from Java 11 or working with Java 17 or 21 already: this course gives you a structured overview of everything you’ve missed – so you can confidently apply modern Java in your projects.

Ideal for teams that have skipped several Java versions and now want to get thoroughly up to date – not in fast-forward mode, but in a way that actually sticks.

If you’d like to cover the same range of topics in a more compact format, the Combined Training Java 17 + 21 + 25 (Compact) offers a 5-day alternative. If you only want to catch up on two specific versions, the Combined Training Java 17 + 21 or the Combined Training Java 21 + 25 is a great choice.

Agenda

Part 1: Java 12-17

Major Features:

  • switch Expressions
  • Text Blocks
  • Records
  • Pattern Matching for instanceof
  • Sealed Classes
  • Strongly Encapsulate JDK Internals

Additional Enhancements:

  • Helpful NullPointerExceptions
  • Hidden Classes
  • Warnings for value-based classes
  • Context-specific deserialization filters

API Improvements:

  • New String methods
  • New Stream methods
  • New Files methods
  • New ByteBuffer methods
  • The Teeing collector
  • Hex formatting and parsing utility

Garbage Collection:

  • Improvements to G1 and Parallel GC
  • New: ZGC and Shenandoah
  • Elastic Metaspace

Performance:

  • Default and dynamic CDS archives
  • Non-volatile mapped byte buffers
  • Specialized TreeMap implementations
  • Decoupling of Compressed Oops and Compressed Class Pointers

Tools:

  • JFR event streaming
  • Packaging tool

Deprecations:

  • Thread suspend(), resume()
  • ThreadGroup stop(), destroy(), isDestroyed(), setDaemon(), and isDaemon()
  • Biased locking
  • And more…

Part 2: Java 18-21

Major Features:

  • Virtual Threads
  • Sequenced Collections
  • Record Patterns
  • Pattern Matching for switch

Additional Features:

  • UTF-8 by default
  • Simple web server
  • Code snippets in Java API documentation
  • New system properties for System.out and System.err encoding
  • Compiler warnings for lossy type casts
  • Key Encapsulation Mechanism API

Bugfixes:

  • IdentityHashMap’s remove() and replace() methods use object identity

API Enhancements:

  • New methods for String, StringBuilder, and StringBuffer
  • New methods for Character
  • New methods for Math
  • HashMap.newHashMap()
  • Additional date-time formats

Garbage Collection:

  • String deduplication for ZGC, SerialGC, ParallelGC
  • G1 enhancements
  • Generational ZGC

Performance:

  • Generational ZGC
  • Alternative fast-locking scheme

Deprecations & Removals:

  • Deprecate finalization for removal
  • Locale constructors
  • URL constructors
  • Thread.stop(), suspend(), resume()
  • ThreadGroup
  • Dynamic loading of agents

Part 3: Java 22-25

Major Features:

  • Unnamed Variables & Patterns
  • Foreign Function & Memory API
  • Markdown Documentation Comments
  • Stream Gatherers
  • Synchronize Virtual Threads without Pinning
  • Scoped Values
  • Compact Source Files and Instance Main Methods

Other New Features:

  • Module Import Declarations
  • Launch multi-file source-code programs
  • Console methods with explicit Locale
  • Class-File API
  • Key Derivation Function API

API Enhancements:

  • Locale-dependent list patterns
  • Support for Duration until another Instant

Garbage Collection:

  • G1 GC improvements
  • ZGC: Generational mode by default

Performance / Memory Footprint:

  • Compact Object Headers
  • Ahead-of-Time Class Loading & Linking
  • Relax alignment of array elements
  • Change LockingMode default from LM_LEGACY to LM_LIGHTWEIGHT
  • Linking run-time images without JMODs

Deprecations & Removals:

  • Thread.countStackFrames()
  • Old core reflection implementation
  • Deprecations and removals in sun.misc.Unsafe
  • Thread.suspend(), resume() und ThreadGroup.suspend(), resume(), stop()
  • Security Manager

Looking Ahead:

  • Primitive Types in patterns, instanceof, and switch
  • Stable Values
  • Vector API
  • Structured Concurrency

Is this the training your team needs?

Request now – no obligation

Why learn with me?

I’ve been working with Java for over 20 years – as a developer, CTO, trainer, author, and speaker.

In that time, I’ve helped companies modernize complex Java systems and develop their teams sustainably.

With HappyCoders.eu, I’ve built one of the most widely read Java blogs in the German-speaking world.

My goal: to teach complex topics in a way that is understandable, practical, and immediately applicable. The intensive course is particularly well suited for this – because we take the time to really get to the bottom of the difficult questions.

Rated 4.97 out of 5 on ProvenExpert

More about me

Any questions?

Participation & Booking

Can individuals book this training?

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:

How many participants are possible?

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.

How does booking work?

The easiest way is the request form or an email to schulung@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.

Prerequisites

What prior Java experience is required?

Ideally, you already know Java 11. If you’ve been working with Java 8, you’ll be fine too – the most important differences are put into context during the course. As a general rule, I recommend at least two years of hands-on experience with Java.

What technical requirements do we need?

All participants need an up-to-date IDE with at least Java 25 – I use IntelliJ IDEA myself. Java 25 or later should also be installed in the terminal, as we’ll run some of the exercises there.

Schedule & Content

What does a training day look like?

Each day has six hours of net training time – usually with two short breaks and a longer lunch break in between. We align the exact schedule with your working hours – that’s flexible.

How much time is theory, how much is practice?

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.

Can we adjust or prioritize individual agenda topics?

Yes, that’s no problem. Dropping topics or weighting them differently – as long as I don’t have to restructure the training materials, there are no extra costs.

If you need more extensive changes – for example, combining content from different courses or adding entirely new topics – I’ll be happy to prepare an individual offer.

What exactly does “customizable content” mean?

Within the existing agenda, the weighting can be adjusted: shortening topics, setting priorities, changing the order. That’s free of charge.

Beyond that, more far-reaching adjustments are possible – such as combining content from different courses or completely new topic blocks. This involves extra effort, so I’ll prepare an individual offer for it.

Format & Materials

Which platform do we use for virtual training?

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.

Do participants receive materials to keep?

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.

Prices & Costs

What do the travel expenses include?

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.

Are there discounts for booking multiple trainings?

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.

Is this a good fit for your team?

Just write to me – I usually reply within 24 hours.
Or book a free video call right away, and we’ll discuss everything important.

Request now – no obligation

Related trainings

Mastering Java 17 – All New Features Since Java 11

Learn the most important features introduced in Java 12 to 17 – including switch expressions, text blocks, records, and pattern matching. With practical examples for productive use in everyday development.

2 days On-site / online German / English

Mastering Java 21 – All New Features Since Java 17

Get ready for Java 21! Virtual threads, structured concurrency, pattern matching for switch, record patterns, sealed classes, and more. Hands-on and clearly explained, with many exercises for modern Java development.

2 days On-site / online German / English

Mastering Java 25 – All New Features Since Java 21

Stay up to date with Java development: Discover the exciting new features from Java 22 to 25 – from stream gatherers to finalized scoped values and enhanced pattern matching. Perfect for developers aiming to stay ahead of the curve.

2 days On-site / online German / English

Combined Training: Java 17 + 21

In four days, you’ll get a comprehensive overview of all relevant Java updates from version 11 to 21 – with a strong focus on practical use, plenty of exercises, and immediate transfer into your project work.

4 days On-site / online German / English

Combined Training: Java 21 + 25

Learn all essential updates from Java 17 to 25 in just four days – practical, clear, and full of examples for applying modern Java features in your daily projects.

4 days On-site / online German / English

Combined Training: Java 17 + 21 + 25 (Compact)

Learn all important updates since Java 11 in just five days – delivered more compactly and with a focus on the features most relevant for everyday development.

5 days On-site / online German / English