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 of the training
Explore major developments in the Java language, its ecosystem, and the virtual machine to update your development practices.Targeted audience
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.Trainers
Benefits for Participants
- Implement functional programming with lambda expressions;
- Represent data with records;
- Write advanced conditional logic with pattern matching;
- Execute I/O operations in a non-blocking manner with virtual threads;
- Apply parallelism with StructuredTasks;
- Deliver a native application with GraalVM.
Course architecture
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
Java 8 introduces functional programming (lambdas, Stream API), a new date/time API, and tools that have become standard (Optional, CompletableFuture). This module revisits these pillars, which are often underused or poorly exploited.
⦁ 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
This module explores the gradual improvements made to the standard API: Factory Methods, Collections, String, Stream, Optional, etc. The aim is to modernize existing code with more concise and robust practices.
⦁ 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
Project Amber introduces several major syntactic changes, making code lighter and more readable: records, enhanced switch statements, pattern matching, text blocks, and more.
⦁ 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
With Loom, Java offers a new approach to concurrency based on virtual threads. This module illustrates their uses, context management (scoped values), and structured asynchronous processing.
⦁ 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
This module concludes the training by presenting the latest innovations in the Java JVM to better adapt to recent environments: containers, native compilation, optimized memory collection, etc.
⦁ 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.
Pedagogical details
Training architecture
• Explanation, for each concept, of the problem it aims to solve. • Practical application of a concept immediately after it has been presented. • Validation of each step by performing unit tests. • "Common thread" exercise to obtain a complete application at the end of the course. • Multiple-choice questions at the end of each chapter to ensure knowledge acquisition.
Type of training
Private or personalized training
If you have more than 8 people to sign up for a particular course, it can be delivered as a private session right at your offices. Contact us for more details.
Request a quotePrivate or personalized training
If you have more than 8 people to sign up for a particular course, it can be delivered as a private session right at your offices. Contact us for more details.
Request a quote