De Java 8 à Java 24: 11 ans d'évolutions

En 2014, Java 8 apportait au langage Java la programmation fonctionnelle avec les expressions Lambda. Aujourd'hui Java 24 est la version la plus récente, en attendant Java 25 (LTS) dont la sortie est prévue pour septembre 2025.

Plus de 10 ans séparent ces deux versions. Le langage Java a évolué (pattern marching, records, text blocks...), Java SE a évolué (factory methods, scoped variable, structured concurrency) et la JVM a évolué (virtual threads, GraalVM, nouveaux garbage collectors).

Ce cours vous permettra de découvrir et de mettre en pratique ces évolutions et ainsi de maintenir à jours vos connaissances Java.

(14 heures)

En présentiel ou en classe virtuelle
En français ou en anglais
Public

Développeurs et développeuses Java, architectes

Accessible aux personnes en situation de handicap

Délai

Le cours peut être organisé dans un délai d'un mois.

Objectifs

A l'issue du cours vous saurez:

Prérequis

Ce cours demande une connaissance solide des bases de la programmation Java (principes de la programmation orientée objet, types génériques, annotations, expressions lambda), une habitude de travailler avec Eclipse ou IntelliJ.

Méthodes pédagogiques

Programme détaillé

Introduction
  • Le cycle de release des versions de Java.
  • Présentation des JEP (JDK Enhancement Proposal).
  • Présentation des projets Amber, Panama, Loom, Leyden, Valhalla.
Rappel des principales nouveautés apportées par Java 8
->
  • Les expressions lambda et leur traitement par la JVM (invoke dynamic).
  • La représentation du temps avec les classes du package java.time.
  • L'application du paradigme Map Reduce avec les Stream.
  • La classe Optional pour limiter les NullPointerException.
  • Le parallélisme avec CompletableFuture.

Mise en pratique: intégration des Optional, Stream et des expressions lambda dans le projet fil rouge, analyse du bytecode et du principe invoke dynamic.

L'évolution des types de bases de Java SE
java.util
  • Les factory methods pour une instanciation plus concise.
  • De nouvelles méthodes utilitaires dans la classe Objects.
  • Les sequenced collections: retro-conception de l'API java.util.Collection.
  • Les nouvelles méthodes de la classe String.
  • Les nouvelles méthodes de l'interface Stream, les nouveaux Collector.
  • Les nouvelles méthodes de la classe Optional.

Mise en pratique: mise à jour du projet fil rouge pour tirer partie des évolutions des types de base.

Project Amber: la manipulation de données plus expressive
"""
  • Les nouvelles expressions switch.
  • Le pattern matching pour le traitement de données hétérogènes.
  • les records pour la représentation des données.
  • Les sealed classes et sealed interfaces.
  • Les text blocks.

Mise en pratique: manipulation de données avec les records, écriture de branchements complexes avec le pattern matching.

Project Loom: l'exécution non bloquante des opérations I/O
nio
  • Les virtual threads pour gagner en scalabilité.
  • Les scoped values comme alternative aux ThreadLocal.
  • Les StrucuturedTaskScope pour un code asynchrone sans callbacks.

Mise en pratique: activation des virtual thread sur une application web, écriture de traitements de données parallélisés.

Les évolutions de la JVM
GraalVM
  • L'adaptation de la JVM aux conteneurs.
  • GraalVM pour la livraison d'application natives.
  • Les garbages collectors G1 et ZGC pour une gestion optimisée de la mémoire.

Mise en pratique: build d'une image OCI native avec GraalVM et livraison sous forme de conteneur.

Prix et financements

2 12

Réduction de 50% pour les associations reconnues d'utilité publique.

Sources de financements pour les organisations françaises:

Contact

Questions, inscriptions, demande d'adaptation: