Teach on Udemy

Turn what you know into an opportunity and reach millions around the world.

Learn More

Your cart is empty.

Keep shopping

Thinking Beyond Java 8

Name: Thinking Beyond Java 8
Rating: 4.2 (1036 reviews)

Java 9 to 17 Step by Step: Modules, var, Records, Sealed Classes & More

Created byAjay Iyengar

Last updated 8/2025

English

What you'll learn

Starting from Java 9, navigate through every release up to Java 17
Language Features
Garbage Collectors like G1, ZGC, Epsilon, Shenandoah
Super useful tools like Jpackage, JShell, JDK Flight Recorder, and more
Performance-related improvements
Removals and Deprecations
Understand the new JDK release cycle and how the Java language and platform are evolving at a rapid pace
Make well-informed decisions about moving beyond Java 8
Tips on Migration(Examples on JAXB, Hibernate, and Spring Boot)

Course content

12 sections • 163 lectures • 12h 11m total length

Course Introduction3:08
A glimpse of what you will learn from the course5:16
Understanding the Time-Based JDK Releases5:13
Students will get an understanding of the Java release schedule. There are a few changes recently announced, which we will look at in another lecture.
Is Java still free ?2:48
More about the LTS Release3:07
Java 17 is here: LTS release update and a new license(free ?)3:45
Source Code: Downloading and how to navigate?4:24
1. The java_catching_up zip file contains source code that we will refer to throughout the course.
2. The modules_movieflix.zip and multi_modules.zip contain source code that we will refer to when we discuss modules, this is in the next section when we explore Java 9.
3. The JMH_Demo.zip contains source code that we will look at in Section 5 when we explore Java 12 and the concept of JMH.

Section Introduction3:17
Convenience Factory Methods for Collections: An Introduction7:13
Convenience Factory Methods for Collections: Understanding the characteristics7:23
Difference between the static factory of() and Collections.unmodifiableXXX()5:46
G1 Garbage Collector: An Introduction3:31
G1 Garbage Collector: An overview of how the G1 Garbage Collector works3:49
Compact Strings: The basics3:41
Compact Strings: Behind the scenes5:10
Indify String Concatenation: A peek into the bytecode7:42
Modularity: Why was it introduced?6:36
Modules: Understanding the basics5:55
Modules: Getting started with a modular application6:45
Modules: How to requires(s) another module?3:48
Modules: The unnamed module5:03
Modules: The automatic module5:55
Modules: Why do we need the automatic module?4:14
Modules: Quick summary of named, unnamed, and automatic modules5:44
Modules: Getting started with a multi-modular application, an example of two mod9:49
Modules: Advantages of the module system2:57
Understanding the Encapsulated Internal API's and jDeps8:08
jlink, The Java Linker: An Introduction5:15
jlink, The Java Linker: Using the tool with a single module4:03
jlink, The Java Linker: Using the tool with two modules4:05
JShell: An Introduction5:55
JShell: Exploring the commands6:59
Introduction to private methods in an interface3:38
A quick recap of the limit and skip methods introduced in JDK 86:31
Stream API enhancement,takeWhile method: A prelude5:49
Stream API enhancement,takeWhile method: Understanding the basics4:21
Stream API enhancement,dropWhile method: Understanding the basics7:17
Stream API enhancement: Iterate using a Predicate5:49
Stream API enhancement: The ofNullable method7:11
Understanding the meaning of deprecation4:03
Deprecations and Removals4:20
Flow API in Java 9+: Complete Guide0:31
This lecture includes a downloadable PDF guide that introduces the Flow API, a powerful feature added in Java 9 to support reactive programming.

What you’ll find inside:
- A clear explanation of the Flow API and why it was introduced
- The four core interfaces: Publisher, Subscriber, Subscription, and Processor
- Practical examples using `SubmissionPublisher`
- How the Flow API connects with libraries like RxJava and Project Reactor
- Key takeaways to help you build a strong foundation for modern Java development

Even though you may not use the Flow API directly in day-to-day coding, it provides the foundation for many reactive libraries and frameworks.

Download this PDF and keep it as a handy reference — it will strengthen your understanding of Java’s evolution and help you in both learning and interviews.
Exercise1:04

Section Introduction2:11
Local-Variable Type Inference: An Introduction4:03
Local-Variable Type Inference: Java is still statically typed1:23
Local-Variable Type Inference: Where can it be used?5:24
Local-Variable Type Inference: Examples8:26
Local-Variable Type Inference: Some more examples3:56
Local-Variable Type Inference: Few more examples7:40
Local-Variable Type Inference: Final example10:00
Local-Variable Type Inference: Benefits and Summary2:08
A look at the orElseThrow method in the Optional class3:39
Using the copyOf method to create an unmodifiable list, set and map6:16
Application Class-Data Sharing: An Introduction4:34
Application Class-Data Sharing: Getting started with Class-Data sharing4:58
Application Class-Data Sharing: Getting started3:55
Application Class-Data Sharing: Benefits1:49
Improved Docker Container Detection in Java7:17
Exercise0:40

Section Introduction3:41
HTTP Client API: Introduction and motivation5:12
HTTP Client API: An overview of the important components3:30
HTTP Client API: Sending asynchronous requests5:29
HTTP Client API: Summary1:10
Local-Variable Syntax for Lambda Parameters: An Introduction4:27
String API: repeat method2:27
String API: isBlank method3:04
String API: strip method3:32
String API: Difference between strip and trim method2:24
String API: lines method4:54
Epsilon Garbage Collector: An Introduction7:05
Z Garbage Collector: An Introduction4:00
Deprecations and Removals: Java EE and Corba3:02
Deprecations and Removals: Applets and Nashorn2:34
Deprecations and Removals: JavaFX & OpenJFX1:58
Launching Single-File Source-Code Programs: Getting started5:01
Writing scripts using Java: Combining Shebang & Single-File Source-Code Programs5:33
File API: Introduction to the readString and writeString methods5:05
Predicate interface: Improving the readability of the code using the not( )5:19
JDK Flight Recorder: An Introduction6:05
JDK Mission Control: An Introduction6:40
JDK Mission Control: Exploring the User Interface6:40
JFR: Creating a recording & viewing the recording in Mission Control3:18
Exercise0:59

Section Introduction2:10
CompactNumberFormat: Formatting numbers in Compact form4:52
Teeing Collector: Composing two downstream collectors4:31
Files API: Determining equality between two files using the mismatch method3:32
Switch Expressions: A quick preview4:53
Shenandoah Garbage Collector: An Introduction3:59
String API: The indent method5:39
String API: The transform method6:57
Java Microbenchmark Harness(JMH): An Introduction6:44
Java Microbenchmark Harness(JMH): Getting started5:40
Java Microbenchmark Harness(JMH): How to benchmark?7:29
Java Microbenchmark Harness(JMH): Conclusion1:37
Exercise0:47

Section Introduction1:38
Text Blocks: An Introduction4:34
Text Blocks: An Exploration6:28
Text Blocks: Introduction to the two escape sequences4:58
Text Blocks: Overview of what the compiler is doing4:01
Helpful NullPointerException: Overview of the changes3:00
Records: Understanding the basics5:34
Records: Understanding Local Records8:40
Sealed Class: An Introduction4:02
Sealed Class: Examples and Benefits5:04
Other notable changes: A quick summary4:22
Exercise1:17

Section Introduction2:13
Records: Behind the scenes5:07
Records: Creating a record from Map.Entry3:09
Records: Using Records as a compound key in a Map4:36
Records: Using Records to return multiple values5:57
Records: Use cases3:33
Stream API: A quick recap of the flatMap method3:42
Stream API: Introduction to the mapMulti method5:29
Stream API: Refactoring using the mapMulti method & using the new toList method3:25
Pattern Matching for instanceof: An Introduction4:52
Pattern Matching for instanceof: Understand the scope of binding variables5:37
Pattern Matching for instanceof: Future4:28
Using Sealed Types and Records together6:40
Understanding how the JDK Internals are strongly encapsulated by default7:45
jpackage, packaging self-contained Java applications: An Introduction3:52
jpackage, packaging self-contained Java applications : Getting started4:51
Value-Based Classes: Warnings and motivation3:46

Requirements

Programming experience with Java 8 (Some of the code examples contain Lambdas & Streams)
A computer with the latest JDK and an IDE
Basic understanding of Maven (Used only for a handful of lectures)

Description

Java has changed more since Java 9 than at any time in its history. From modules and `var` to records, sealed classes, text blocks, and switch expressions — the language is evolving fast, and keeping up can be a challenge.

This course gives you a step-by-step path from Java 9 through Java 17, making it simple to catch up with all the modern features while building confidence through hands-on exercises.

By the end of this course, you will:

Understand how Java has evolved beyond Java 8
Master new language features like modules, var, records, sealed classes, text blocks, and switch expressions
Explore new garbage collectors, library enhancements, tools, and deprecations
Learn how the new JDK release cycle impacts developers
Gain confidence with practical exercises and solutions
Be better prepared for interviews and real-world projects

Starting from Java 9, we will incrementally move up to Java 17 and explore :

Language Features, Garbage Collectors, Library enhancements, Tools, Removals and Deprecations, and a lot more.

We target a single Java release in every section.

Some of the topics covered -

Text Blocks, Switch Expressions, Records, Pattern Matching for instanceof, Pattern Matching for switch, Sealed Classes
Garbage Collectors - G1, Epsilon, ZGC, Shenandoah
Modularity, jdeps, jlink, jdeprscan
Improved Docker Container Detection
Tool/Toolkit - Jpackage, JShell, JDK Flight Recorder
Factory methods in Collections
Compact Strings
Understand how String concatenation works behind the scenes
Some of the changes in the Stream API
Local Variable Type Inference along with recommendations on usage
Application Class Data Sharing
The new HTTP Client API
Handy String API changes
Writing scripts using the Java programming language
Teeing Collector
JMH (Java Microbenchmark Harness)
Encapsulated JDK internals
Tips on Migration (Examples on JAXB, Hibernate, and Spring Boot)

and more!

Now includes a downloadable PDF guide on the Java Flow API (Java 9+) — a beginner-friendly reference that explains the core reactive programming interfaces with clear examples and key takeaways. This bonus resource strengthens your understanding and helps with interview preparation.

The course will immensely benefit Java developers interested in getting up to speed with the ever-evolving Java language.

There are lots of exercises (along with the solution) that will help you to gain confidence.

The course is not a migration guide but we do cover numerous areas that can have an impact on migration.

What if you have questions?

I offer full support, 7 days a week, answering any questions you have.

Who this course is for:

Java developers interested in getting up to speed with the ever-evolving Java language
You want to learn the new features of modern Java

Thinking Beyond Java 8

What you'll learn

Explore related topics

Course content

Getting started7 lectures • 28min

Exploring Java 936 lectures • 3hr 9min

Exploring Java 1017 lectures • 1hr 18min

Exploring Java 1125 lectures • 1hr 43min

Exploring Java 1213 lectures • 59min

Exploring Java 1310 lectures • 34min

Exploring Java 149 lectures • 33min

Exploring Java 1512 lectures • 54min

Exploring Java 1617 lectures • 1hr 19min

Exploring Java 178 lectures • 30min

Requirements

Description

Who this course is for: