Java évolue à un rythme de six mois entre versions et de deux ans entre LTS, et les équipes qui restent sur des versions anciennes passent à côté de gains majeurs en productivité et en performance. Cette formation synthétise les nouveautés des JDK 8 à 25 LTS : expressions lambda, API Streams et DateTime, système de modules, Records, Sealed Classes, pattern matching, Virtual Threads et Structured Concurrency issus du Project Loom, Foreign Function & Memory API issue du Project Panama, et les chantiers en cours Valhalla et Leyden. Vous repartirez avec une vision claire des fonctionnalités à adopter et une stratégie de migration entre LTS.

Public visé

Développeurs, architectes et chefs de projets techniques.

Prérequis

Avoir suivi cette formation, ou en maîtriser les thèmes abordés :

Java - Initiation

Objectifs pédagogiques

À l’issue de cette formation, vous serez capable de :

Exploiter les apports majeurs des JDK 8, 11, 17, 21 et 25 LTS
Adopter la programmation fonctionnelle Java — lambda, streams, API DateTime
Maîtriser le pattern matching moderne — switch, records, sealed, déconstruction
Organiser un projet en modules JPMS et migrer un existant
Exploiter les Virtual Threads et la concurrence structurée
Communiquer avec du code natif via Foreign Function & Memory API
Comprendre les chantiers en cours — Valhalla, Leyden — pour anticiper les versions à venir
Choisir une stratégie de migration entre versions LTS

Programme

Jour 1 - Matin

Programmation fonctionnelle Java

Lambda expressions et interfaces fonctionnelles — Java 8

comprendre la motivation des lambda — code as data
écrire des lambda — syntaxe, capture de variables, références de méthode
exploiter les interfaces fonctionnelles standard
créer ses propres interfaces fonctionnelles avec @FunctionalInterface

Travaux pratiques :

Refondre une API legacy basée sur des classes anonymes en lambda et références de méthode

API Streams — Java 8 et apports ultérieurs

créer un stream depuis collections, fichiers ou builders
composer des opérations intermédiaires
terminer un pipeline par une opération de collecte ou de réduction
choisir entre stream séquentiel et parallèle
exploiter les apports récents — takeWhile, dropWhile, Collectors.teeing
découvrir les Stream Gatherers, finalisés en Java 24

Travaux pratiques :

Transformer un traitement impératif sur une collection volumineuse en pipeline streams, avec mesure de la version parallèle

API DateTime — Java 8

distinguer les types principaux de l’API DateTime
formater et parser avec DateTimeFormatter
réaliser des opérations courantes
gérer les fuseaux horaires et l’heure d’été

Travaux pratiques :

Implémenter un planificateur multi-fuseaux avec calcul de durées

Jour 1 - Après-midi

Expressivité du langage moderne

Inférence de type

déclarer des variables locales avec var depuis Java 10
typer les paramètres lambda avec var depuis Java 11
comprendre les limites de var et les bonnes pratiques

Travaux pratiques :

Refondre du code verbeux en utilisant var de manière idiomatique

Text blocks — Java 15

écrire du SQL, JSON, HTML multi-lignes lisible
maîtriser l’indentation et les séquences d’échappement

Travaux pratiques :

Remplacer des concaténations de chaînes complexes par des text blocks

Switch expressions et pattern matching — Java 14 à 21

écrire des switch comme expressions avec yield
éviter le fallthrough avec la flèche ->
pattern matcher dans switch avec déconstructions et gardes
pattern matcher pour instanceof

Travaux pratiques :

Implémenter un visiteur d’AST avec switch + pattern matching, comparé à la version classique

Records et record patterns — Java 16 et 21

déclarer un record et son canonical constructor
ajouter des méthodes statiques et compactes
utiliser les record patterns pour la déconstruction

Travaux pratiques :

Remplacer des DTO classiques par des records et exploiter la déconstruction dans des patterns

Sealed classes et interfaces — Java 17

déclarer une hiérarchie scellée — sealed, permits, non-sealed
combiner sealed + records + switch pour modéliser des sommes algébriques
comprendre l’apport pour le compilateur en termes d’exhaustivité

Travaux pratiques :

Modéliser une AST métier en hiérarchie scellée et la traiter par switch exhaustif

Compact Source Files et Instance Main Methods — Java 25, JEP 512

écrire un programme Java sans déclaration de classe explicite
exécuter un fichier source unique sans étape de compilation depuis Java 22
positionner ces nouveautés comme rampe d’apprentissage

Travaux pratiques :

Écrire un mini-utilitaire CLI en compact source file et l’exécuter directement

Jour 2 - Matin

Modules et outillage du JDK

Système de modules JPMS — Java 9

déclarer un module via module-info.java
comprendre l’encapsulation forte et la modularisation forte du JDK
distinguer module nommé, module automatique, classpath
migrer une application non modulaire

Travaux pratiques :

Modulariser une application existante par étapes successives

Module Import Declarations — finalisé en Java 25

importer l’intégralité des packages exportés d’un module — import module
réduire le boilerplate au démarrage d’un fichier
combiner avec les compact source files

Travaux pratiques :

Refondre des imports verbeux en imports de module

Outillage JDK

explorer du code à la volée avec JShell depuis Java 9
empaqueter une application native avec jpackage depuis Java 16
créer une image runtime sur mesure avec jlink
inspecter un binaire avec jdeps et jdeprscan

Travaux pratiques :

Produire un exécutable natif léger d’une application via jlink + jpackage

API outillage moderne

manipuler le bytecode avec la Class-File API, finalisée en Java 24
documenter avec Markdown dans Javadoc depuis Java 23
exploiter le Simple Web Server pour un prototype depuis Java 18

Travaux pratiques :

Générer ou modifier une classe à la volée avec la Class-File API

Jour 2 - Après-midi

Concurrence moderne

Rappels sur la concurrence pré-Loom

exploiter le package java.util.concurrent
composer des traitements asynchrones avec CompletableFuture
comprendre les limites du modèle thread-pool

Travaux pratiques :

Refondre une chaîne de callbacks en pipeline CompletableFuture

Virtual Threads — Java 21 LTS, issus du Project Loom

comprendre la différence avec les threads OS
créer et utiliser un Virtual Thread avec Thread.ofVirtual()
adapter du code bloquant existant sans réécriture massive
repérer les pièges — synchronized pinning, ThreadLocal coûteux

Travaux pratiques :

Réécrire un serveur HTTP simple en Virtual Threads et comparer la scalabilité

Structured Concurrency

exprimer des unités de travail concurrentes en arborescence avec StructuredTaskScope
propager annulation et résultats sans race conditions
combiner avec les Virtual Threads

Travaux pratiques :

Paralléliser un appel à plusieurs services dépendants avec StructuredTaskScope

Scoped Values — finalisés en Java 25

partager une valeur immuable dans un sous-graphe d’appels
remplacer ThreadLocal dans un contexte massivement Virtual Threads
combiner avec Structured Concurrency

Travaux pratiques :

Migrer un usage de ThreadLocal vers ScopedValue dans une application Virtual Threads

Jour 3 - Matin

Performance, interopérabilité et données

Foreign Function & Memory API — Java 22, issue du Project Panama

accéder à de la mémoire off-heap avec Arena et MemorySegment
décrire des structures avec MemoryLayout
appeler du code natif sans JNI via Linker
comparer FFM et JNI

Travaux pratiques :

Appeler une bibliothèque C standard depuis Java via FFM

Vector API

vectoriser des calculs numériques avec VectorSpecies et FloatVector
comprendre l’auto-vectorisation et ses limites
positionner l’API par rapport aux opérations stream classiques

Travaux pratiques :

Implémenter un produit scalaire vectorisé et le mesurer face à la version scalaire

Garbage Collection moderne

choisir un GC selon la charge — G1, ZGC, Generational ZGC, Shenandoah
exploiter ZGC Generational, finalisé en Java 23
mesurer et tuner avec Java Flight Recorder JFR
exploiter JFR Cooperative Sampling depuis Java 25

Travaux pratiques :

Profiler une application avec JFR et comparer G1 et Generational ZGC

Jour 3 - Après-midi

Nouveautés récentes et perspectives

JDK 23 — panorama

adopter Pattern Matching for switch finalisé
documenter en Markdown Javadoc finalisé
découvrir Module Import Declarations, Stream Gatherers et Class-File API en preview

Travaux pratiques :

Réécrire un module existant en exploitant les apports finalisés du JDK 23

JDK 24 — panorama

exploiter Stream Gatherers et Class-File API en versions finales
découvrir Stable Values en preview
intégrer la cryptographie post-quantique — ML-KEM, ML-DSA

Travaux pratiques :

Implémenter un Gatherer personnalisé sur un cas métier

JDK 25 LTS — focus version cible 2026

exploiter Compact Source Files & Instance Main Methods finalisés via JEP 512
adopter Module Import Declarations et Flexible Constructor Bodies, tous deux finalisés
migrer ses ThreadLocal vers Scoped Values finalisés
gérer les certificats avec PEM Encodings of Cryptographic Objects
profiler avec JFR Cooperative Sampling
découvrir Primitive Types in Patterns et Stable Values en preview

Travaux pratiques :

Démarrer un projet Java 25 from scratch en exploitant les apports finalisés

JDK 26 — mars 2026, perspectives

suivre les itérations sur Stable Values, Valhalla, Leyden

Projets transverses

positionner Project Valhalla — value classes, universal generics
positionner Project Leyden — AOT compilation, CRaC
découvrir Project Babylon — accélération ML / GPU côté Java
situer Loom et Panama, déjà délivrés mais en évolution continue

Stratégie de migration entre LTS

planifier un saut Java 8 → 11 → 17 → 21 → 25
identifier les fonctionnalités retirées — String Templates, modules JEE/CORBA
gérer les dépendances tierces et l’outillage build
tirer parti des features de chaque LTS sans dette préventive

Travaux pratiques :

Projet final : élaborer un plan de migration argumenté d’une application Java 8 vers Java 25, livrables sous forme de fiche de risques et de roadmap

Modalités d’évaluation des acquis

En cours de formation, par des travaux pratiques. En fin de formation, par un questionnaire d’auto-évaluation.

Voir aussi

Vous serez peut-être intéressés par les formations suivantes :

Formation DEV-JAVA-320 — Java - Nouveautés versions 8 à 25. Domaine : Développement. Niveau : Avancé. Durée : 3 jours (21 heures). Mots-clés : java, nouveautés, lambda, streams, modules, pattern matching, virtual threads, panama, perfectionnement. Cylian Formation, Dijon.