Nearly ten years separate Java 8 from Java 25. This long cycle, punctuated by biannual releases, has seen the Java language, the standard library (Java SE), and the JVM (Java Virtual Machine) evolve profoundly, in step with JEPs (JDK Enhancement Proposals) and OpenJDK projects such as Amber, Loom, and Valhalla.
From functional programming introduced by lambdas to virtual threads, records, pattern matching, new collection types, structured concurrency mechanisms, and native image generation with GraalVM, the contributions are numerous and sometimes underutilized in business.
This training course provides an up-to-date and structured overview of the main developments in the language, the standard ecosystem (SE), and the virtual machine. Each new feature is contextualized, put into perspective, and then tested through the gradual adaptation of a common application project.
Objectives
Explore major developments in the Java language, its ecosystem, and the virtual machine to update your development practices.
Is it for you ?
Java developers, software architects, technical staff involved in the maintenance, development, or modernization of existing Java applications (Java 8 or earlier)
Prerequisite
This course requires a solid understanding of the fundamentals of Java programming (principles of object-oriented programming, generic types, annotations, lambda expressions), and experience working with Eclipse or IntelliJ.
Your benefits
Content
This training course combines practical examples and theoretical developments to review the different layers of the Java platform (language, API, JVM). Each module is based on an application project that is enriched as the course progresses, allowing participants to experiment with the latest language features in concrete use cases.
Introduction
This module provides the necessary background to follow the evolution of Java through its different versions. It presents how the release cycle works, JEPs (JDK Enhancement Proposals), and the flagship projects of OpenJDK.
- The Java release cycle.
- Presentation of JEPs (JDK Enhancement Proposals).
- Presentation of the Amber, Panama, Loom, Leyden, and Valhalla projects.
- Boundaries between language, API, and JVM
Java 8: the foundations of modern Java
- Lambda expressions and their processing by the JVM (invoke dynamic).
- Time representation with classes from the java.time package.
- Applying the Map Reduce paradigm with Streams.
- The Optional class for limiting NullPointerExceptions.
- Parallelism with CompletableFuture.
See more + / -
Java 8: the foundations of modern Java
- Lambda expressions and their processing by the JVM (invoke dynamic).
- Time representation with classes from the java.time package.
- Applying the Map Reduce paradigm with Streams.
- The Optional class for limiting NullPointerExceptions.
- Parallelism with CompletableFuture.
Practical application: integration of Optional, Stream, and lambda expressions into the main project, analysis of bytecode and the invoke dynamic principle.
Java SE API: changes to basic types
- Factory methods for more concise instantiation.
- New utility methods in the Objects class.
- Sequenced collections: retro-design of the java.util.Collection API.
- New methods in the String class.
- New methods in the Stream interface, new Collectors.
- New methods in the Optional class.
- StableValue to reinforce immutability.
Practical application: redesigning an application process with the new standard methods.
Project Amber: more expressive data manipulation
- New switch expressions.
- Pattern matching for processing heterogeneous data.
- Records for data representation.
- Sealed classes and sealed interfaces.
- Text blocks.
Practical application: data manipulation with records, writing complex branches with pattern matching.
Project Loom: non-blocking execution of I/O operations
- Virtual threads for increased scalability.
- Scoped values as an alternative to ThreadLocal.
- StructuredTaskScope for asynchronous code without callbacks.
Practical application: enabling virtual threads on a web application, writing parallelized data processing.
JVM developments
- Adapting the JVM to containers.
- GraalVM for native application delivery.
- G1 and ZGC garbage collectors for optimized memory management.
Practical application: generating a native application with GraalVM and containerized delivery.
💡 Useful information
Our training sessions are offered in Montreal or Quebec City, in person or in virtual format. Dates and locations are provided when you select your session below. If you have any questions regarding registration, schedules, the language of instruction, or cancellation policies, please consult our FAQ .
Trainers
Private or personalized training
Do you have several employees interested in the same training course? Whether in person at your offices or remotely in virtual mode, we offer private training courses tailored to your team's needs. Group rates are available. Contact us for more details or request a quote online.
Request a quote