Cette présentation brosse une revue détaillée des nouveautés qui sont proposées en standard, en preview et en incubation dans la version 21 LTS du JDK issues des projets d’OpenJDK :
- Amber : Record Patterns, Pattern Matching for switch, String Templates, Unnamed Patterns and Variables, Unnamed Classes and Instance Main Methods
- Loom : Virtual Threads, Structured Concurrency, Scoped Values
- et Panama : Foreign Function & Memory API, Vector API
mais aussi de fonctionnalités dans les API de Java Core qui ne font pas l'objet de JEP et dans la JVM HotSpot.
Cette présentation brosse une revue détaillée des nouveautés qui sont proposées en standard, en preview et en incubation dans la version 21 LTS du JDK issues des projets d’OpenJDK :
- Amber : Record Patterns, Pattern Matching for switch, String Templates, Unnamed Patterns and Variables, Unnamed Classes and Instance Main Methods
- Loom : Virtual Threads, Structured Concurrency, Scoped Values
- et Panama : Foreign Function & Memory API, Vector API
mais aussi de fonctionnalités dans les API de Java Core qui ne font pas l'objet de JEP et dans la JVM HotSpot.
Les nouveautés de Java 21 - Rencontres dev Toulon octobre 2023.pdfJean-Michel Doudoux
Cette présentation brosse une revue détaillée des nouveautés qui sont proposées en standard, en preview et en incubation dans la version 21 LTS du JDK issues des projets d’OpenJDK :
- Amber : Record Patterns, Pattern Matching for switch, String Templates, Unnamed Patterns and Variables, Unnamed Classes and Instance Main Methods
- Loom : Virtual Threads, Structured Concurrency, Scoped Values
- et Panama : Foreign Function & Memory API, Vector API
mais aussi de fonctionnalités dans les API de Java Core qui ne font pas l'objet de JEP et dans la JVM HotSpot.
Cette présentation brosse une revue détaillée des nouveautés qui sont proposées en standard, en preview et en incubation dans la version 21 LTS du JDK issues des projets d’OpenJDK :
- Amber : Record Patterns, Pattern Matching for switch, String Templates, Unnamed Patterns and Variables, Unnamed Classes and Instance Main Methods
- Loom : Virtual Threads, Structured Concurrency, Scoped Values
- et Panama : Foreign Function & Memory API, Vector API
mais aussi de fonctionnalités dans les API de Java Core qui ne font pas l'objet de JEP et dans la JVM HotSpot.
Les versions 19 et 20 de Java, publiées en septembre et mars derniers, sont les 10eme et 11eme release en application du modèle de release tous les 6 mois.
En attendant la publication de Java 21, la prochaine version LTS publiée en septembre de cette année, et pour en donner quelques aperçus, cette présentation brosse une revue détaillée des nouveautés introduites dans ces nouvelles versions de Java, issues des projets Amber, Panama et Loom d’OpenJDK ainsi que des fonctionnalités non incluses dans des JEPs.
Cette présentation brosse une revue détaillée des nouveautés qui sont proposées en standard, en preview et en incubation dans la version 21 LTS du JDK issues des projets d’OpenJDK :
- Amber : Record Patterns, Pattern Matching for switch, String Templates, Unnamed Patterns and Variables, Unnamed Classes and Instance Main Methods
- Loom : Virtual Threads, Structured Concurrency, Scoped Values
- et Panama : Foreign Function & Memory API, Vector API
mais aussi de fonctionnalités dans les API de Java Core qui ne font pas l'objet de JEP et dans la JVM HotSpot.
En attendant la publication de Java 21, la prochaine version diffusée en septembre de cette année, et pour en donner quelques aperçus, cette présentation brosse une revue détaillée des nouveautés qui devraient être proposées dans cette future version LTS de Java, issues des projets Amber, Loom et Panama d’OpenJDK.
Les versions 19 et 20 de Java, publiées en septembre et mars derniers, sont les 10eme et 11eme release en application du modèle de release tous les 6 mois.
En attendant la publication de Java 21, la prochaine version LTS publiée en septembre de cette année, et pour en donner quelques aperçus, cette présentation brosse une revue détaillée des nouveautés introduites dans ces nouvelles versions non-LTS de Java, issues des projets Amber, Panama et Loom d’OpenJDK ainsi que des fonctionnalités non incluses dans des JEPs.
Cette présentation brosse une revue détaillée des nouveautés qui sont proposées en standard, en preview et en incubation dans la version 22 du JDK issues des projets d’OpenJDK :
- Amber : String Templates, Unnamed Patterns and Variables, Unnamed Classes and Instance Main Methods
- Loom : Structured Concurrency, Scoped Values
- et Panama : Foreign Function & Memory API, Vector API
Mais aussi des fonctionnalités dans les API de Java Core et dans la JVM HotSpot qui ne font pas l'objet de JEP.
Cette présentation brosse une revue détaillée des nouveautés qui sont proposées en standard, en preview et en incubation dans la version 21 LTS du JDK issues des projets d’OpenJDK :
- Amber : Record Patterns, Pattern Matching for switch, String Templates, Unnamed Patterns and Variables, Unnamed Classes and Instance Main Methods
- Loom : Virtual Threads, Structured Concurrency, Scoped Values
- et Panama : Foreign Function & Memory API, Vector API
mais aussi de fonctionnalités dans les API de Java Core qui ne font pas l'objet de JEP et dans la JVM HotSpot.
Les nouveautés de Java 21 - Rencontres dev Toulon octobre 2023.pdfJean-Michel Doudoux
Cette présentation brosse une revue détaillée des nouveautés qui sont proposées en standard, en preview et en incubation dans la version 21 LTS du JDK issues des projets d’OpenJDK :
- Amber : Record Patterns, Pattern Matching for switch, String Templates, Unnamed Patterns and Variables, Unnamed Classes and Instance Main Methods
- Loom : Virtual Threads, Structured Concurrency, Scoped Values
- et Panama : Foreign Function & Memory API, Vector API
mais aussi de fonctionnalités dans les API de Java Core qui ne font pas l'objet de JEP et dans la JVM HotSpot.
Cette présentation brosse une revue détaillée des nouveautés qui sont proposées en standard, en preview et en incubation dans la version 21 LTS du JDK issues des projets d’OpenJDK :
- Amber : Record Patterns, Pattern Matching for switch, String Templates, Unnamed Patterns and Variables, Unnamed Classes and Instance Main Methods
- Loom : Virtual Threads, Structured Concurrency, Scoped Values
- et Panama : Foreign Function & Memory API, Vector API
mais aussi de fonctionnalités dans les API de Java Core qui ne font pas l'objet de JEP et dans la JVM HotSpot.
Les versions 19 et 20 de Java, publiées en septembre et mars derniers, sont les 10eme et 11eme release en application du modèle de release tous les 6 mois.
En attendant la publication de Java 21, la prochaine version LTS publiée en septembre de cette année, et pour en donner quelques aperçus, cette présentation brosse une revue détaillée des nouveautés introduites dans ces nouvelles versions de Java, issues des projets Amber, Panama et Loom d’OpenJDK ainsi que des fonctionnalités non incluses dans des JEPs.
Cette présentation brosse une revue détaillée des nouveautés qui sont proposées en standard, en preview et en incubation dans la version 21 LTS du JDK issues des projets d’OpenJDK :
- Amber : Record Patterns, Pattern Matching for switch, String Templates, Unnamed Patterns and Variables, Unnamed Classes and Instance Main Methods
- Loom : Virtual Threads, Structured Concurrency, Scoped Values
- et Panama : Foreign Function & Memory API, Vector API
mais aussi de fonctionnalités dans les API de Java Core qui ne font pas l'objet de JEP et dans la JVM HotSpot.
En attendant la publication de Java 21, la prochaine version diffusée en septembre de cette année, et pour en donner quelques aperçus, cette présentation brosse une revue détaillée des nouveautés qui devraient être proposées dans cette future version LTS de Java, issues des projets Amber, Loom et Panama d’OpenJDK.
Les versions 19 et 20 de Java, publiées en septembre et mars derniers, sont les 10eme et 11eme release en application du modèle de release tous les 6 mois.
En attendant la publication de Java 21, la prochaine version LTS publiée en septembre de cette année, et pour en donner quelques aperçus, cette présentation brosse une revue détaillée des nouveautés introduites dans ces nouvelles versions non-LTS de Java, issues des projets Amber, Panama et Loom d’OpenJDK ainsi que des fonctionnalités non incluses dans des JEPs.
Cette présentation brosse une revue détaillée des nouveautés qui sont proposées en standard, en preview et en incubation dans la version 22 du JDK issues des projets d’OpenJDK :
- Amber : String Templates, Unnamed Patterns and Variables, Unnamed Classes and Instance Main Methods
- Loom : Structured Concurrency, Scoped Values
- et Panama : Foreign Function & Memory API, Vector API
Mais aussi des fonctionnalités dans les API de Java Core et dans la JVM HotSpot qui ne font pas l'objet de JEP.
Cette présentation brosse une revue détaillée des nouveautés qui sont proposées en standard, en preview et en incubation dans la version 22 du JDK issues des projets d’OpenJDK :
- Amber : String Templates, Unnamed Patterns and Variables, Unnamed Classes and Instance Main Methods
- Loom : Structured Concurrency, Scoped Values
- et Panama : Foreign Function & Memory API, Vector API
Mais aussi des fonctionnalités dans les API de Java Core et dans la JVM HotSpot qui ne font pas l'objet de JEP.
Ce cours concerne la manipulation des chaines de caractères et les expressions régulières. La première partie présente la classe str Python ainsi que les opérations qu'il est possible de faire sur des objets str. La seconde partie concerne les expressions regulières qui permettent de valider des chaines de caractères ou d'en extraire des sous-chaines qui satisfont un motif donné. On y voit finalement comment utiliser le module re Python.
Voici le chapitre 2 sur les chaînes de caractères en Java.
Si vous avez des remarques ou suggestions afin de le parfaire.
N’hésitez pas à me contacter via mon email:
pr.azizdarouichi@gmail.com.
Bonne lecture.
Présentation des nouveautés apportées par la version 7 du langage C# : Méthodes locales, Tuples, Déconstructeurs, Pattern matching, Variables de sortie, Membres sous forme d’expression, Amélioration de la levée des exceptions, ...
Swift est désormais open source ! "Google considérerait Swift comme un langage « de première classe » pour Android" pouvait-on lire en avril sur le réseau. Et enfin un portage Android du langage a été "merge" dans la base de code officielle de Swift.
Bon tout ceci est un bon prétexte pour apprendre ce nouveau langage et les possibilités qu'il peut nous apporter en terme de développement. Une comparaison avec Java sera notamment proposée afin de montrer les similitudes et differences entre ces deux langages .
Java SE 8 est sûrement la version la plus importante et la plus impactante pour les développeurs. Deux ans après sa sortie, ce talk propose des retours sur les bonnes ou moins bonnes utilisations des principales fonctionnalités de Java 8. Une connaissance de ces fonctionnalités est requise.
Java SE 8 est sûrement la version la plus importante et la plus impactante pour les développeurs. Deux ans après sa sortie, ce talk propose des retours sur les bonnes ou moins bonnes utilisations des principales fonctionnalités de Java 8. Une connaissance de ces fonctionnalités est requise.
Beaucoup d’applications utilisent encore Java 8 mais Java a beaucoup évolué depuis notamment avec la diffusion de deux versions LTS.
L’objectif de ce talk est de revenir sur certaines de ces nombreuses évolutions de Java, notamment récentes afin d’en profiter dans nos applications. Au-delà des évolutions syntaxiques et dans les API, ce sera aussi l’occasion de justifier la migration vers des versions plus récentes de Java.
Voxxeddays Lux 2022 - Profiling et monitoring avec le JDKJean-Michel Doudoux
Java Flight Recorder (JFR) est une fonctionnalité de la JVM qui après activation enregistre des événements émis par son activité mais aussi celle de l’application et même du système d’exploitation avec un très faible overhead. Il est possible d’émettre ses propres événements et même de consommer des événements grâce à une API de Java 14. Depuis Java 11, JFR est open source et il est donc utilisable maintenant en production sans licence commerciale. L’exploitation de ces événements avec l’outil JMC peut être particulièrement appréciable lors d’activité de profiling et de monitoring. Cette session sera l’occasion de faire un tour d’horizon de ces fonctionnalités qui peuvent s’avérer utiles pour certaines problématiques.
Contenu connexe
Similaire à Les nouveautés de Java 21 - Devoxx France 2024.pdf
Cette présentation brosse une revue détaillée des nouveautés qui sont proposées en standard, en preview et en incubation dans la version 22 du JDK issues des projets d’OpenJDK :
- Amber : String Templates, Unnamed Patterns and Variables, Unnamed Classes and Instance Main Methods
- Loom : Structured Concurrency, Scoped Values
- et Panama : Foreign Function & Memory API, Vector API
Mais aussi des fonctionnalités dans les API de Java Core et dans la JVM HotSpot qui ne font pas l'objet de JEP.
Ce cours concerne la manipulation des chaines de caractères et les expressions régulières. La première partie présente la classe str Python ainsi que les opérations qu'il est possible de faire sur des objets str. La seconde partie concerne les expressions regulières qui permettent de valider des chaines de caractères ou d'en extraire des sous-chaines qui satisfont un motif donné. On y voit finalement comment utiliser le module re Python.
Voici le chapitre 2 sur les chaînes de caractères en Java.
Si vous avez des remarques ou suggestions afin de le parfaire.
N’hésitez pas à me contacter via mon email:
pr.azizdarouichi@gmail.com.
Bonne lecture.
Présentation des nouveautés apportées par la version 7 du langage C# : Méthodes locales, Tuples, Déconstructeurs, Pattern matching, Variables de sortie, Membres sous forme d’expression, Amélioration de la levée des exceptions, ...
Swift est désormais open source ! "Google considérerait Swift comme un langage « de première classe » pour Android" pouvait-on lire en avril sur le réseau. Et enfin un portage Android du langage a été "merge" dans la base de code officielle de Swift.
Bon tout ceci est un bon prétexte pour apprendre ce nouveau langage et les possibilités qu'il peut nous apporter en terme de développement. Une comparaison avec Java sera notamment proposée afin de montrer les similitudes et differences entre ces deux langages .
Java SE 8 est sûrement la version la plus importante et la plus impactante pour les développeurs. Deux ans après sa sortie, ce talk propose des retours sur les bonnes ou moins bonnes utilisations des principales fonctionnalités de Java 8. Une connaissance de ces fonctionnalités est requise.
Java SE 8 est sûrement la version la plus importante et la plus impactante pour les développeurs. Deux ans après sa sortie, ce talk propose des retours sur les bonnes ou moins bonnes utilisations des principales fonctionnalités de Java 8. Une connaissance de ces fonctionnalités est requise.
Beaucoup d’applications utilisent encore Java 8 mais Java a beaucoup évolué depuis notamment avec la diffusion de deux versions LTS.
L’objectif de ce talk est de revenir sur certaines de ces nombreuses évolutions de Java, notamment récentes afin d’en profiter dans nos applications. Au-delà des évolutions syntaxiques et dans les API, ce sera aussi l’occasion de justifier la migration vers des versions plus récentes de Java.
Voxxeddays Lux 2022 - Profiling et monitoring avec le JDKJean-Michel Doudoux
Java Flight Recorder (JFR) est une fonctionnalité de la JVM qui après activation enregistre des événements émis par son activité mais aussi celle de l’application et même du système d’exploitation avec un très faible overhead. Il est possible d’émettre ses propres événements et même de consommer des événements grâce à une API de Java 14. Depuis Java 11, JFR est open source et il est donc utilisable maintenant en production sans licence commerciale. L’exploitation de ces événements avec l’outil JMC peut être particulièrement appréciable lors d’activité de profiling et de monitoring. Cette session sera l’occasion de faire un tour d’horizon de ces fonctionnalités qui peuvent s’avérer utiles pour certaines problématiques.
Au cours des 10 précédentes années, nous avons eu des sessions de Devoxx FR et plusieurs versions dont certaines majeures de Java.
L’objectif de ce talk est de revenir rétrospectivement sur certaines annonces et sur certaines des nombreuses évolutions de Java, notamment récentes afin d’en profiter dans nos applications. Au-delà des évolutions syntaxiques et dans les API, ce sera aussi l’occasion de justifier la migration vers des versions plus récentes de Java.
Ce n'est pas qu'un slogan politique mais bien la réalité pour Java depuis l'année écoulée.
A tel point que plusieurs caractéristiques historiques de Java sont partiellement remises en cause notamment la lenteur patente entre deux releases, l'embonpoint endémique du JRE/JDK, et même la sacro sainte rétro-compatibilité, ... Faisons un tour de ces évolutions qui sont parfois de profonds changements.
Ce n'est pas qu'un slogan politique mais bien la réalité pour Java depuis l'année écoulée.
A tel point que plusieurs caractéristiques historiques de Java sont partiellement remises en cause notamment la lenteur patente entre deux releases, l'embonpoint endémique du JRE/JDK, et même la sacro sainte rétro-compatibilité, ...
Faisons un tour de ces évolutions qui sont parfois de profonds changements avant de fêter le 10ème anniversaire du Nantes JUG.
Les versions de Java se suivent et leurs engouements ne se ressemblent pas : la version 8 de Java est probablement celle qui a suscité le plus d’intérêts chez les développeurs. Java 9, au contraire, est la version de Java qui génère le plus de craintes et d’interrogations voir de peurs. Il faut se préparer pour utiliser Java 9 d’autant que Java 10 est déjà là et les versions suivantes vont s’enchaîner. Le but de ce talk est de parcourir les avantages et les intérêts à utiliser ces nouvelles versions mais aussi certaines difficultés possibles lors de la migration.
Anniversaire Paris JUG - Deja 10 ans - retour vers le futur avec JMXJean-Michel Doudoux
Présentation lors du dixième anniversaire du Paris JUG.
Le but est de profiter de ce dixième anniversaire pour faire une rétrospective des apports de Java et du Paris JUG à la communauté durant cette décennie et esquisser leur futur.
Les versions de Java se suivent et leurs engouements ne se ressemblent pas : la version 8 de Java est probablement celle qui a suscité le plus d’intérêts chez les développeurs. Java 9, au contraire, est la version de Java qui génère le plus de craintes et d’interrogations voir de peurs. Il faut se préparer pour utiliser Java 9 d’autant que Java 10 est déjà là et les versions suivantes vont s’enchaîner. Le but de ce talk est de parcourir les avantages et les intérêts à utiliser ces nouvelles versions mais aussi certaines difficultés possibles lors de la migration.
Les versions de Java se suivent et leurs engouements ne se ressemblent pas : la version 8 de Java est probablement celle qui a suscité le plus d’intérêts chez les développeurs. Java 9, au contraire, est la version de Java qui génère le plus de craintes et d’interrogations voir de peurs. Il faut se préparer pour utiliser Java 9 d’autant que Java 10 est déjà là et les versions suivantes vont s’enchaîner. Le but de ce talk est de parcourir les avantages et les intérêts à utiliser ces nouvelles versions mais aussi certaines difficultés possibles lors de la migration.
Le sujet principal de Java 9 est le support de la modularité mais Java 9 propose aussi de nombreuses autres fonctionnalités. Ce talk a pour but de faire une revue des principales d’entre-elles en attendant la sortie de Java 9 : support de standards, nouvelles API, évolutions dans certaines API, mises à jour des outils du JDK et améliorations de la JVM.
2. DEVOXX FRANCE 2024
Sciam
2
Java 21 est diffusé le 19 septembre 2023
JDK 21 est une version LTS
Depuis la réduction de 3 à 2 ans entre 2 LTS après Java 17
OpenJDK 21 est l’implémentation de référence
Des spécifications de la version 21 de Java SE
Des patchs seront disponibles
Au moins jusqu’à la prochaine version LTS
Java SE en 2024
Java poursuit son évolution
En respectant le rythme de release tous les 6 mois
3. DEVOXX FRANCE 2024
Sciam
3
Java 21
Les spécifications dans la JSR 396
15 JEPs :
JEP 430 : String Templates (Preview)
JEP 431 : Sequenced Collections
JEP 439 : Generational ZGC
JEP 440 : Record Patterns
JEP 441 : Pattern Matching for switch
JEP 442 : Foreign Function & Memory API (Third Preview)
JEP 443 : Unnamed Patterns and Variables (Preview)
JEP 444 : Virtual Threads
JEP 445 : Unnamed Classes and Instance Main Methods (Preview)
JEP 446 : Scoped Values (Preview)
JEP 448 : Vector API (Sixth Incubator)
JEP 449 : Deprecate the Windows 32-bit x86 Port for Removal
JEP 451 : Prepare to Disallow the Dynamic Loading of Agents
JEP 452 : Key Encapsulation Machanism API
JEP 453 : Structured Concurrency (Preview)
5. DEVOXX FRANCE 2024
Sciam
5
Roadmap
Les fonctionnalités
du projet Amber
du projet Loom
Les évolutions
Les fonctionnalités du projet Panama
dans les API Java Core
dans la JVM Hotspot
dans les outils du JDK
dans la sécurité
6. 6
Les fonctionnalités du
projet Amber
Record Patterns
Pattern Matching for switch
String Templates (Preview)
Unnamed Patterns and Variables (Preview)
Unnamed Classes and Instance Main Methods (Preview)
7. DEVOXX FRANCE 2024
Sciam
7
Record Patterns
En preview en Java 19 (JEP 420) et 20 (JEP 432)
Standard en Java 21
Type pattern utilisable avec le pattern matching sur les records
Ajouter un nouveau pattern utilisable dans le pattern matching
Le record pattern pour déconstruire les valeurs d’un record
record Employe(String nom, String prenom) {}
Object o = new Employe("Nom1", "Prenom1");
if (o instanceof Employe emp) {
System.out.println("Employe : "+emp.nom()+" "+emp.prenom());
}
if (o instanceof Employe(String nom, String prenom)) {
System.out.println("Employe : "+nom+" "+prenom);
}
8. DEVOXX FRANCE 2024
Sciam
8
Record Patterns
Utilisable avec une instruction instanceof ou switch
Type pattern et record pattern peuvent être combinés
Dans un même switch
Java 20 : utilisable dans une boucle for améliorée
switch (o) {
case Employe emp -> System.out.println(emp);
case Grade(String code,String designation) -> System.out.println("Grade " + designation + "(" + code + ")");
default -> System.out.println("Type non supporté");
}
List<Employe> employes = List.of(new Employe("Nom1", "Prenom1"));
for(Employe(var nom, var prenom) : employes) {
System.out.println(nom + " " + prenom);
}
Java 21 : retiré
9. DEVOXX FRANCE 2024
Sciam
9
Record Patterns
Le nom des variables peut être différents de celui des composants
Seuls l’ordre et le type des composants doivent être respectés
Utilisation possible de l’inférence du type dans le pattern
Java 20 : support de l'inférence des types d’arguments génériques
record Mono<T>(T val) implements Container<T> {}
Mono<Mono<String>> monoDeMono = new Mono<>(new Mono<>("valeur"));
if (o instanceof Employe(var nom, var prenom)) {
System.out.println("Employe : "+nom+" "+prenom);
}
if (o instanceof Employe(String n, String p)) {
System.out.println("Employe : " + n + " " + p);
}
if (monoDeMono instanceof Mono(Mono(var s))) {
System.out.println("mono contient " + s);
}
10. DEVOXX FRANCE 2024
Sciam
10
Record Patterns
Les record patterns peuvent être imbriqués
La valeur null ne correspond à aucun record pattern
record Grade(String code, String designation) {}
record Employe(String nom, String prenom, Grade grade) {}
Object o = new Employe("Nom1", "Prenom1", new Grade("DEV", "Développeur"));
if (o instanceof Employe(var nom, var prenom, Grade(var code, var designation))) {
System.out.println("Employe : " + nom + " " + prenom + ", "+ designation);
}
11. DEVOXX FRANCE 2024
Sciam
11
Pattern Matching for switch
Historiquement 4 preview en Java
17 (JEP 406), 18 (JEP 420), 19 (JEP 427) et 20 (JEP 433)
But : utiliser le pattern matching dans une instruction switch
En maintenant la compatibilité syntaxique
Avec un support de la valeur null contrairement à la levée historique d’une NPE
Standard en Java 21
static String getDesignation(Object obj) {
String designation = switch (obj) {
case Terrain t -> "Terrain";
case null -> "Instance null";
default -> "Pas un terrain";
};
return designation;
}
Plusieurs patterns utilisables
Type pattern
Teste la correspondance sur un type
12. DEVOXX FRANCE 2024
Sciam
12
Pattern Matching for switch
Record Pattern
Déconstruit un record
Utilisation possible d’un Guarded pattern case label
Combine un pattern et une expression booléenne dans un case
Parenthesized pattern retiré en Java 21
static String getDesignation(Object obj) {
String designation = switch (obj) {
case Terrain t
when (t.getSurface() > 1000) -> "Grand terrain";
case Terrain t -> "Petit terrain";
case null -> "Instance null";
default -> "Pas un terrain";
};
return designation;
}
Utilise le nouveau mot clé contextuel when
13. DEVOXX FRANCE 2024
Sciam
13
Pattern Matching for switch
Possibilité de mixer constantes et patterns
Au runtime une exception de type java.lang.MatchException est levée
Exemple : sur un type scellé ou une énumération par exemple
L’exhaustivité des cas d’un switch doit être satisfaite
Sinon erreur de compilation : implique fréquemment l’utilisation d’un default
String getEnv(String env) {
return switch (env) {
case "Prod" -> "Production";
case String s -> "Hors production";
};
}
static String formater(Number nombre) {
return switch (nombre) { // erreur : the switch expression does not cover all possible input values
case Integer i -> String.format("Entier %d", i);
case Long l -> String.format("Entier long %d", l);
}; }
14. DEVOXX FRANCE 2024
Sciam
14
Pattern Matching for switch
Le compilateur vérifie la dominance des patterns
Les patterns les plus restrictifs doivent être avant les moins restrictifs
Idem avec les guarded patterns case label
static String formater(Object o) {
return switch (o) {
case Number n -> String.format("Nombre %f", n);
case Integer i -> String.format("Entier %d", i); // erreur this case label is dominated by a preceding case label
case Long l -> String.format("Entier long %d", l);
default -> o.toString();
};
}
String taille = switch (chaine) {
case String s -> "Moyenne";
case String s when s.length() < 10 -> "Petite"; // erreur this case label is dominated by a preceding case label
case String s when s.length() > 100 -> "Grande";
};
15. DEVOXX FRANCE 2024
Sciam
15
Pattern Matching for switch
Sémantique d'exécution d’un switch avec le pattern matching
Lorsque la valeur est null et que le cas null n’est pas explicitement géré :
Elle est étroitement alignée sur la sémantique historique des switchs
public static void main(String[] args) {
String chaine = null;
switch (chaine) {
case String s -> {
System.out.println("traitement chaine");
System.out.println("taille : " + s.length());
}
}
}
Exception in thread "main" java.lang.NullPointerException
at java.base/java.util.Objects.requireNonNull(Objects.java:233)
at TestSwitchPattern.main(TestSwitchPattern.java:5)
16. DEVOXX FRANCE 2024
Sciam
16
Pattern Matching for switch
Java 21 autorise les constantes d'énumération qualifiées
Dans les cases des switchs afin d’éviter d’avoir à utiliser un guarded pattern case label
public sealed interface MonInterface permits MonEnum, MaClasse {}
public enum MonEnum implements MonInterface { PAIRE, IMPAIRE }
public final class MaClasse implements MonInterface {}
// …
static void traiter(MonInterface c) {
switch (c) {
// case MonEnum e when e == MonEnum.PAIRE -> { System.out.println("Paire"); }
case MonEnum.PAIRE -> { System.out.println("Paire"); }
case MonEnum.IMPAIRE -> { System.out.println("Impaire"); }
case MonEnum e -> { System.out.println("MonEnum"); }
case MaClasse mc -> { System.out.println("MaClasse"); }
}
}
17. DEVOXX FRANCE 2024
Sciam
17
String Templates (Preview)
Courant de devoir créer des chaînes de caractères composées
À partir d'une combinaison de textes littéraux
Et de valeurs ou d'expressions
De nombreux langages proposent l'interpolation de chaînes
Comme alternative à la concaténation de chaînes
Historiquement plusieurs fonctionnalités, toutes avec inconvénients
String s = x + " + " + y + " = " + (x + y);
String s = String.format("%2$d + %1$d = %3$d", x, y, x + y);
String t = "%2$d + %1$d = %3$d".formatted(x, y, x + y);
MessageFormat mf = new MessageFormat("{0} + {1} = {2}");
String s = mf.format(x, y, x + y);
String s = new StringBuilder()
.append(x)
.append(" + ")
.append(y)
.append(" = ")
.append(x + y)
.toString();
18. DEVOXX FRANCE 2024
Sciam
18
String Templates (Preview)
Mais le résultat peut parfois engendrer des soucis indirects
Exemple : SQL ou JSON injection
En combinant :
- Un texte littéral avec des expressions intégrées
- Et un processeur de templates
Le but : enrichir le langage Java avec des string templates
Qui complètent les chaînes littérales et les blocs de texte
Pour produire des chaînes de caractères construites dynamiquement
Avec la clarté de l’interpolation et un résultat plus sûr
Possibilité de créer une instance de type quelconque
Avec un processeur de templates personnalisés
19. DEVOXX FRANCE 2024
Sciam
19
String Templates (Preview)
Nouveau type d'expression dans le langage : les templates expressions
Pour effectuer une interpolation de chaîne pour créer une chaîne ou un objet
Une template expression est composée de trois éléments :
1) Un processeur de templates (STR)
2) Un caractère point (U+002E), celui utilisé dans les autres expressions
3) Un template ("Bonjour {prenom}")
qui contient une expression intégrée ({prenom})
Syntaxiquement, ressemble à une chaîne littérale avec un préfixe :
String prenom = "Jean-Michel";
String message = STR."Bonjour {prenom}";
Le template peut utiliser plusieurs lignes de code source
En utilisant une syntaxe similaire à celle des blocs de texte
String prenom = "Jean-Michel";
String message = STR."""
Bonjour
{prenom}""";
20. DEVOXX FRANCE 2024
Sciam
20
String Templates (Preview)
3 processeurs de templates fournis dans le JDK
FormatProcessor.FMT : effectue une interpolation pour créer une chaîne
Il interprète les spécificateurs de format à gauche des expressions intégrées
Les spécificateurs de format sont ceux définis dans java.util.Formatter
StringTemplace.STR : effectue une interpolation pour créer une chaîne
int x = 10, y = 20;
String s = STR."{x} + {y} = {x + y}";
StringTemplate.RAW : produit un objet de type StringTemplate
import static java.util.StringTemplate.RAW;
…
String prenom = "Jean-Michel";
StringTemplate st = RAW."Bonjour {prenom}";
String message = STR.process(st);
import static java.util.FormatProcessor.FMT;
…
int x = 10, y = 20;
String message = FMT."%05d{a} + %05d{b} = %05d{a + b}";
21. DEVOXX FRANCE 2024
Sciam
21
String Templates (Preview)
Possibilité de définir des processeurs de templates personnalisés
Pour générer des chaînes ou des objets qui peuvent être validés
Implémenter l’unique méthode process()
Une instance de l'interface fonctionnelle StringTemplate.Processor
var JSON = StringTemplate.Processor.of((StringTemplate st) -> new JSONObject(st.interpolate()));
String nom = "Durant";
String prenom = "Pierre";
JSONObject doc = JSON."""
{
"nom": "{nom}",
"prenom": "{prenom}"
}""";
Utilisation de la fabrique StringTemplate.Processor::of
Pour obtenir une instance
22. DEVOXX FRANCE 2024
Sciam
22
Unnamed Patterns and Variables (Preview)
Enrichit le langage d’une syntaxe
Pour les patterns inutilisés dans les records pattern imbriqués
Et les variables inutilisées qui doivent être déclarées
Unnamed pattern : un pattern inconditionnel qui ne correspond à rien
Utilisable dans un pattern imbriqué à la place d'un type ou record pattern
Utilisant le 51eme mot clé réservé de Java : _
record Grade(String code, String designation) {}
record Employe(String nom, String prenom, Grade grade) {}
Object o = new Employe("Nom1", "Prenom1", new Grade("DEV", "Développeur"));
if (o instanceof Employe(var nom, var prenom, _)) {
System.out.println("Employe : " + nom + " " + prenom);
}
23. DEVOXX FRANCE 2024
Sciam
23
Unnamed Patterns and Variables (Preview)
Unnamed pattern variable :
Utilisable avec tous types de patterns
Unnamed variable : peut être initialisée mais non utilisée dans
Une variable locale dans un bloc
Une ressource dans un try-with-resources
L'en-tête d'une boucle for et for améliorée
Une exception d'un bloc catch
Un paramètre formel d'une expression Lambda
if (o instanceof Employe(var nom, var _, _)) {
System.out.println("Employe : " + nom);
}
try (var _ = ScopedContext.acquire()) {
var _ = service.traiter((_, _) -> System.out.printn("traiter"));
} catch (Throwable _) { }
Utilisable plusieurs fois dans la même portée
24. DEVOXX FRANCE 2024
Sciam
24
Unnamed Patterns and Variables (Preview)
Utile dans des switchs avec des patterns sur des types scellés
Risque de bug
en cas d’ajout d’un type
Impossible d’avoir plusieurs patterns
nommés dans un case
sealed interface Forme permits Cercle, Carre, Rectangle {}
void traiterFormeRonde(Forme forme) {
switch(forme) {
case Cercle c -> afficher(c);
case Carre c -> {}
case Rectangle r -> {}
}
}
switch(forme) {
case Cercle c -> afficher(c);
default -> {}
}
switch(forme) {
case Cercle c -> afficher(c);
case Carre _, Rectangle _ -> {}
}
Utilisation possible de default
Préférable d’utiliser
des unnamed variables
25. DEVOXX FRANCE 2024
Sciam
25
Unnamed Classes and Instance Main Methods (Preview)
Plutôt compliqué
Les buts :
Faire évoluer le langage pour simplifier les programmes simples
Et faciliter l’apprentissage des débutants avec le langage Java
Deux évolutions dans une classe unique
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello world");
}
}
void main() {
System.out.println("Hello world");
}
Classe sans nom (unnamed class)
class HelloWorld {
void main() {
System.out.println("Hello world");
}
}
Méthode d’instance main()
27. DEVOXX FRANCE 2024
Sciam
27
Virtual Threads
Chaque thread Java est directement mappé à un thread de l’OS
Depuis Java 1.0
Ce modèle n’est pas optimal
Car un thread de la plateforme est coûteux en ressources
Notamment à cause de la taille fixe (par défaut) de sa pile
Décharge la JVM de se préoccuper de tâches réalisées par l’OS
Ordonnancement et changement de contexte des threads
Cela limite le nombre de threads qui peuvent être utilisés
Or on utilise de plus en plus de threads
Qui généralement passent beaucoup de temps à attendre la fin d’une opération bloquante
28. DEVOXX FRANCE 2024
Sciam
28
Virtual Threads
Introduction d’un nouveau type de threads : des threads virtuels
En standard Java 21 (JEP 444)
En preview Java 19 (JEP 425) et 20 (JEP 436)
Ce sont des threads « légers » gérés dans la JVM
Non lié à un thread de la plate-forme dédié
Qu’ils utilisent uniquement lors de l’utilisation de la CPU par ses traitements
Plusieurs objectifs :
• Conserver le style « un thread par requête »
Avec une meilleure utilisation des ressources requises
• Assurer une adoption par le code existant
Qui utilise l'API java.lang.Thread avec un impact minimum
• Permettre le débogage, le profilage et le dépannage
Avec les outils existants du JDK
29. DEVOXX FRANCE 2024
Sciam
29
Virtual Threads
Exécutent du code qui ne bloque pas les threads de l’OS
Contrairement aux verrous ou aux opérations bloquantes (I/O par exemple)
Si le thread virtuel exécute une action bloquante dans les API du JDK
La JVM enregistrement la stack dans le heap et exécute l’action en non bloquante
Mapping M:N entre threads virtuels et threads de l’OS
Grâce à un ForkJoinPool dédié qui fournit les threads porteurs (carrier threads)
Le thread porteur peut alors exécuter un autre thread virtuel
Une fois l’action non bloquante terminée
L’exécution des traitements du thread virtuel est reprise sur un thread porteur
Potentiellement différent
Ce mécanisme est géré en interne par les API du JDK
En utilisant des objets de type Continuation et ContinuationScope
Et est transparent pour le développeur
30. DEVOXX FRANCE 2024
Sciam
30
Virtual Threads
La classe finale package-private java.lang.VirtualThread
Hérite de java.lang.Thread
Pas de constructeur public
L’interface scellée Thread.Buidler propose deux interfaces filles
Thread.Builder.OfVirtual et Thread.Builder.OfPlatform
Dont on obtient une instance avec Thread::ofVirtual et Thread::ofPlatform
Le plus simple est d’utiliser Thread::startVirtualThread
Pour démarrer un nouveau thread virtuel qui exécute un Runnable
Thread t = Thread.startVirtualThread(() -> {
System.out.println("Thread : " + Thread.currentThread());
});
var threadVirtuel = Thread.ofVirtual().name("app-thread-virtuel-", 0).start(() -> {
System.out.println(Thread.currentThread());
});
threadVirtuel.join();
31. DEVOXX FRANCE 2024
Sciam
31
Virtual Threads
Plusieurs restrictions sur les threads virtuels :
Ne pas mettre les threads virtuels dans un pool
Aucune utilité vue leur faible coût de création
• Ils sont obligatoirement des threads démons
• La priorité est obligatoirement Thread.NORM_PRIORITY
• stop(), resume(), suspend() lèvent une UnsupportedOperationException
• Ils ne peuvent pas être associés à un ThreadGroup
• getThreadGroup() renvoie un groupe "VirtualThreads" fictif qui est vide
• getAllStackTraces() renvoie une Map qui contient uniquement que les threads de l’OS
plutôt que de tous les threads
32. DEVOXX FRANCE 2024
Sciam
32
Virtual Threads
Peuvent améliorer le débit des applications
Lorsque le nombre de tâches simultanées est important
Et que les tâches ne requièrent pas de manière intensive la CPU
• L’exécution d’un bloc de code synchronized
Il est préférable d’utiliser si possible un ReentrantLock
Deux scénarios bloquants peuvent limiter l’intérêt des threads virtuels
Car ils laissent le thread virtuel associé à son thread porteur
-Djdk.tracePinnedThreads=full ou short
• Lors de l’exécution d’une méthode native
Option de la JVM pour identifier ces cas
Un événement JFR : jdk.VirtualThreadPinned
33. DEVOXX FRANCE 2024
Sciam
33
Structured Concurrency (preview)
Propose un nouveau modèle de programmation
Grâce au traitement de plusieurs tâches
Exécutées dans différents threads virtuels comme une seule unité de travail
Le but : simplifier la programmation multithread
En rationalisant la gestion des erreurs et l'annulation,
En améliorant la fiabilité et en renforçant l'observabilité
Fork/Join et concurrence structurée sont complémentaires
Fork/Join
Conçu pour traiter des tâches à forte
intensité de calcul sur une courte durée
Utilise des threads de l’OS
Complexe à mettre œuvre
Concurrence structurée
Conçue pour traiter des tâches à forte
intensité d'E/S
Utilise des threads virtuels
Facile à mettre en œuvre
34. DEVOXX FRANCE 2024
Sciam
34
Créer une instance dans un try-with-resource
Facture getFacture(String codeClient, long idCommande) throws ExecutionException, InterruptedException,
TimeoutException {
Facture resultat = null;
try (var scope = new StructuredTaskScope()) {
}
return resultat;
}
Structured Concurrency (preview)
Invoquer la méthode fork() pour chaque sous-tâche à exécuter
Facture getFacture(String codeClient, long idCommande) throws ExecutionException, InterruptedException,
TimeoutException {
Facture resultat = null;
try (var scope = new StructuredTaskScope()) {
Subtask<Client> clientFuture = scope.fork(() -> this.getClient(codeClient));
Subtask<Commande> commandeFuture = scope.fork(() -> this.getCommande(idCommande));
}
return resultat;
}
Attendre la fin de l’exécution des sous-tâches
• Soit sans timeout en utilisant la méthode join()
• Soit avec timeout en utilisant la méthode joinUntil()
Facture getFacture(String codeClient, long idCommande) throws ExecutionException, InterruptedException,
TimeoutException {
Facture resultat = null;
try (var scope = new StructuredTaskScope()) {
Subtask<Client> clientFuture = scope.fork(() -> this.getClient(codeClient));
Subtask<Commande> commandeFuture = scope.fork(() -> this.getCommande(idCommande));
scope.joinUntil(Instant.now().plusSeconds(15));
}
return resultat;
}
La mise en œuvre en plusieurs étapes
Facture getFacture(String codeClient, long idCommande) throws ExecutionException, InterruptedException,
TimeoutException {
Facture resultat = null;
try (var scope = new StructuredTaskScope()) {
Subtask<Client> clientFuture = scope.fork(() -> this.getClient(codeClient));
Subtask<Commande> commandeFuture = scope.fork(() -> this.getCommande(idCommande));
scope.joinUntil(Instant.now().plusSeconds(15));
resultat = this.genererFacture(clientFuture.get(), commandeFuture.get());
}
return resultat;
}
Exploiter les résultats obtenus dans des instances de type Subtask (Future en Java 20)
35. DEVOXX FRANCE 2024
Sciam
35
Structured Concurrency (preview)
La classe StructuredTaskScope.ShutdownOnFailure
Propose un modèle invoke all
Qui exécute toutes les sous-tâches
Et termine toutes les sous-tâches en cours si une sous-tâche lève une exception
Facture getFacture(String codeClient, long idCommande)
throws ExecutionException, InterruptedException, TimeoutException {
Facture resultat = null;
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
Subtask<Client> clientFuture = scope.fork(() -> this.getClient(codeClient));
Subtask<Commande> commandeFuture = scope.fork(() -> this.getCommande(idCommande));
scope.joinUntil(Instant.now().plusSeconds(15));
scope.throwIfFailed();
resultat = this.genererFacture(clientFuture.get(), commandeFuture.get());
}
return resultat;
}
36. DEVOXX FRANCE 2024
Sciam
36
Structured Concurrency (preview)
La classe StructuredTaskScope.ShutdownOnSuccess
Propose un modèle invoke any
Qui renvoie le résultat de la première sous-tâche terminée
Et termine les autres sous-tâches restantes
Temperature getTemperature(String ville) throws InterruptedException, ExecutionException {
Temperature resultat = null;
try (var scope = new StructuredTaskScope.ShutdownOnSuccess<Temperature>()) {
serviceMeteos.forEach(f -> {
scope.fork(() -> f.getTemperature(ville));
}
);
scope.join();
resultat = scope.result();
}
return resultat;
}
37. DEVOXX FRANCE 2024
Sciam
37
Structured Concurrency (preview)
Possibilité de créer son propre scope
En héritant de la classe StructuredTaskScope
Et en y implémentant ses propres règles métiers
class ComposantLePlusLegerScope extends StructuredTaskScope<Composant> {
private final Collection<Composant> composants = new ConcurrentLinkedQueue<>();
private final Collection<Throwable> exceptions = new ConcurrentLinkedQueue<>();
@Override
protected void handleComplete(Subtask<? extends Composant> subtask) {
switch (subtask.state()) {
case SUCCESS -> this.composants.add(subtask.get());
case FAILED -> this.exceptions.add(subtask.exception());
case UNAVAILABLE -> {}
}
}
38. DEVOXX FRANCE 2024
Sciam
38
Structured Concurrency (preview)
public Exception exceptions() {
RuntimeException exception = new RuntimeException("Impossible d'obtenir le composant le plus
leger");
exceptions.forEach(exception::addSuppressed);
return exception;
}
public Composant getComposant() throws Exception {
return composants.stream().min(Comparator.comparing(Composant::poids))
.orElseThrow(this::exceptions);
}
}
39. DEVOXX FRANCE 2024
Sciam
39
Scoped Values (Preview)
Pour partager des objets dans le code exécuté par un thread
Historiquement depuis Java 1.2, on utilise une variable de type ThreadLocal
L’API ScopedValue tente de remédier à ces inconvénients
Mais cela présente plusieurs risques :
Mutable, fuite de mémoire, consommation de ressources
public final static ScopedValue<String> VALEUR = ScopedValue.newInstance();
En incubation dans Java 20 (JEP 429)
En preview dans Java 21 (JEP 446)
Création d’une instance généralement statique et publique
Stocker et de partager des données immuables
Pour une durée de vie limitée à des traitements du thread qui les a écrits
40. DEVOXX FRANCE 2024
Sciam
40
Scoped Values (Preview)
where() pour définir une valeur, chainable pour plusieurs valeurs
run() : sous la forme d’une implémentation de Runnable
Pour exécuter une tâche dans le thread courant
String valeur = ScopedValue.where(VALEUR, "test")
.<String>call(monService::traiter);
System.out.println((VALEUR.isBound() ? VALEUR.get() : "non definie"));
ScopedValue.where(VALEUR, "test").run(() -> { afficherValeur(); });
get() pour obtenir la valeur ou lève une NoSuchElementException
isBound() pour savoir si une valeur est associée au thread
Ou call() : sous la forme d’une implémentation de Callable
41. DEVOXX FRANCE 2024
Sciam
41
Scoped Values (Preview)
Réassociation d’une valeur pour un traitement sous-jacent
Partage avec les threads virtuels d’une StucturedTaskScope
ScopedValue.where(VALEUR, "valeur", () -> {
try (var scope = new StructuredTaskScope<String>()) {
afficherValeur();
scope.fork(monServiceA::traiter);
scope.fork(monServiceB::traiter);
scope.joinUntil(Instant.now().plusSeconds(10));
} catch (InterruptedException | TimeoutException e) {
e.printStackTrace();
}
});
ScopedValue.where(VALEUR, "test").run(() -> {
afficherValeur(); // test
ScopedValue.where(VALEUR, "test-autre").run(monService::traiter); // test-autre
afficherValeur(); // test
});
43. DEVOXX FRANCE 2024
Sciam
43
Sequenced collections
L’API Collections propose des collections ordonnées
Mais n’est pas homogène dans les fonctionnalités proposées
Chacune avec leurs méthodes, dont certaines pas évidentes ou inexistantes
Les opérations liées à l'ordre de parcours sont soit incohérentes soit absentes
Des implémentations permettent d'obtenir le premier ou le dernier élément
Idem pour le parcours dans l’ordre inverse
Premier élément Dernier élément
List list.get(0) list.get(list.size() - 1)
Deque deque.getFirst() deque.getLast()
SortedSet sortedSet.first() sortedSet.last()
LinkedHashSet linkedHashSet.iterator().next()
Introduire 3 nouvelles interfaces
Pour représenter des collections avec un ordre de parcours défini
SequencedCollection, SequencedSet et SequencedMap
44. DEVOXX FRANCE 2024
Sciam
44
Sequenced collections
Elles possèdent :
Des éléments parcourables du premier au dernier élément dans un certain ordre
Fournissent des API uniformes pour accéder au 1er et dernier élément,
Ajouter / supprimer le premier / dernier élément
Et pour parcourir ses éléments dans l'ordre inverse
45. DEVOXX FRANCE 2024
Sciam
45
La classe java.net.http.HttpClient
Implémente l’interface AutoClosable
Plusieurs méthodes ont été ajoutées pour gérer l’arrêt :
boolean awaitTermination(Duration)
Bloque jusqu'à ce que toutes les opérations soient terminées
ou jusqu'à ce que la durée soit écoulée
void close()
boolean isTerminated()
void shutdown()
Demande un arrêt ordonné des requêtes précédemment soumises
Aucune nouvelle requête n'est acceptée
void shutdownNow()
try (var client = HttpClient.newHttpClient()) {
// utilisation du client
}
46. DEVOXX FRANCE 2024
Sciam
46
Les évolutions dans les autres API
Ajout dans les classes java.lang.StringBuffer et StringBuilder
repeat(CharSequence, int) et repeat(int, int)
Ajout dans la classe java.lang.String
int indexOf(String str, int beginIndex, int endIndex)
int indexOf(int ch, int beginIndex, int endIndex)
String[] splitWithDelimiters(String regex, int limit)
Agit comme la méthode split() mais renvoie aussi le délimiteur
Ajout dans la classe java.lang.Math et StrictMath
Surcharges de clamp(valeur, min, max)
la valeur retournée est comprise entre min et max
Pour les types primitifs double, float, long et int
Ajout dans la classe java.util.regex.Pattern
String[] splitWithDelimiters(CharSequence input int limit)
Agit comme la méthode split() mais renvoie aussi le délimiteur
47. DEVOXX FRANCE 2024
Sciam
47
Les évolutions dans les autres API
Ajout de méthodes dans la classe java.utils.Collections
newSequencedSetFromMap(SequencedMap)
unmodifiableSequencedCollection(SequencedCollection)
unmodifiableSequencedMap(SequencedMap)
unmodifiableSequencedSet(SequencedSet)
void shuffle(List<?>, RandomGenerator) : surcharge avec RandomGenerator
Ajout de méthodes dans la classe java.util.Locale
Stream<Locale> availableLocales()
String caseFoldLanguageTag(String)
pour formatter le code langue selon la RFC5646
String langue = Locale.caseFoldLanguageTag("fr-fr"); // fr-FR
var randomizer = RandomGenerator.getDefault();
Collections.shuffle(liste,randomizer);
Ajout de méthodes dans la classe java.lang.Character
pour le support des Emojis
48. 48
Les évolutions
dans la JVM HotSpot
Generational ZGC
Deprecate the Windows 32-bit x86 Port for Removal
Prepare to Disallow the Dynamic Loading of Agents
49. DEVOXX FRANCE 2024
Sciam
49
Generational ZGC
Rendre le ramasse-miettes ZGC générationnel
Activation avec les options : -XX:+UseZGC -XX:+ZGenerational
Tout en maintenant les caractéristiques actuelles
ZGC générationnel devrait être une meilleure solution
Pour la plupart des cas d'utilisation que le ZGC non générationnel
Les tailles de tas allant de quelques centaines de Mo à 16 To
Les temps de pause ne doivent pas dépasser 1 milliseconde
50. DEVOXX FRANCE 2024
Sciam
50
Les évolutions dans G1
Durant les Full GC, autorisation des objets volumineux à être déplacés
Permet de réduire les risques d’OOME liés à la fragmentation des régions
Le « Hot Card Cache » a été retiré
Permet de réduire la consommation de mémoire native de 0.2%
Durant les full GC, amélioration du compactage
La fonction de GC préventifs a été complètement retirée
Le tear down et set up des TLABs par thread ont été parallélisés
Pour réduire les temps de pauses avec beaucoup de threads
51. DEVOXX FRANCE 2024
Sciam
51
Prepare to Disallow the Dynamic Loading of Agents
Le but est d’émettre un avertissement
lorsqu’un agent est chargé dynamiquement dans une JVM en cours d'exécution
Utilisation l'option -XX:+EnableDynamicAgentLoading de la JVM
Pour permettre de charger dynamiquement des agents sans avertissement
Pour préparer les utilisateurs à une future version
qui interdira le chargement dynamique des agents par défaut
sauf pour les outils de maintenance
L’option -Djdk.instrument.traceUsage de la JVM
affiche un message et une stacktrace
lors de l’invocation de l’API java.lang.Instrument
facilite l’identification les bibliothèques
qui utilisent des agents chargés dynamiquement
53. DEVOXX FRANCE 2024
Sciam
53
Les vues JFR (views)
Support des vues JFR
Qui permettent d’afficher une agrégation d’événements
La commande JFR.view de la commande jcmd sur une JVM
Par défaut les 10 dernières minutes ou les derniers 32Mo
Modifiable avec les options les options maxage et maxsize
Sur un enregistrement : l’option view de la commande jfr
Plusieurs options de formatage
+/- 70 vues prédéfinies sont proposées
hot-methods, gc-pauses, pinned-threads, gc, memory-leaks-by-class, ...
Pour obtenir la liste des vues : jcmd <pid> JFR.view ou jfr view
jfr view [--verbose] [--width <integer>] [--truncate <mode>] [--cell-height <integer>] <view> <file>
jcmd <pid > JFR.view <view>
54. DEVOXX FRANCE 2024
Sciam
54
Erreur si plusieurs ; entre imports
Avant Java 21
Le compilateur javac autorise d’avoir plusieurs ; entre des imports
Java 21
Le compilateur javac interdit d’avoir plusieurs points-virgules entre imports
C:>javac MaClasse.java
MaClasse.java:1: error: extraneous semicolon
import java.util.List;;
^
1 error
String langue = Locale. import java.util.List;;
import java.util.Set;
class MaClasse { }
("fr-fr"); // fr-FR
C:>javac MaClasse.java
C:>
56. DEVOXX FRANCE 2024
Sciam
56
La sécurité
Mises à jour de certificats racine des CA dans le keystore cacert
Support de l’algorithme de signature standard "HSS/LMS" (RFC 8554)
Augmentation de la taille par défaut des clés de plusieurs algorithmes
L'implémentation du KeychainStore de macOS
expose maintenant les certificats avec une confiance appropriée
dans le domaine de l'utilisateur, le domaine de l'administrateur, ou les deux
Les options -genseckey et –importpass de keytool affichent un warning
Lorsque l'option –keyalg utilise des algo basés sur des mots de passe faibles
Suppression de l’API ContentSigner
Et des options -altsigner et –altsignerpath de l’outil jarsigner
57. DEVOXX FRANCE 2024
Sciam
57
L’API Key Encapsulation Mecanism
KEM permet l’échange d’une clé symétrique partagée sécurisée
En utilisant les API du package javax.crypto
KeyPairGenerator kpg = KeyPairGenerator.getInstance("X25519");
KeyPair kp = kpg.generateKeyPair();
Un générateur d’une paire de clé (publique/privée)
KEM kemSender = KEM.getInstance("DHKEM");
KEM.Encapsulator sender = kemSender.newEncapsulator(kp.getPublic());
KEM.Encapsulated encapsulated = sender.encapsulate();
// envoyer le byte[] retourné par encapsulated.encapsulation()
KEM kemReceiver = KEM.getInstance("DHKEM");
KEM.Decapsulator receiver = kemReceiver.newDecapsulator(kp.getPrivate());
SecretKey sharedKey = receiver.decapsulate(encapsulated.encapsulation());
Une fonction d’encapsulation qui utilise la clé publique pour chiffrer
Une fonction de désencapsulation qui utilise la clé privée pour déchiffrer
Configuration possible des algorithmes de génération de clé et de chiffrement
59. DEVOXX FRANCE 2024
Sciam
59
Foreign Function & Memory API (Third Preview)
Historiquement, fusion de 2 JEPs introduites en incubation :
Foreign-Memory Access API en Java 14 (JEP 370, 383, et 393)
Et Foreign Linker API en Java 16 (JEP 389)
Proposée en incubation en Java 17 (JEP 412) et Java 18 (JEP 419)
Attention : cette API évolue beaucoup
Dans chacune des versions de Java où elle est proposée
Proposée en preview en Java 19 (JEP 424), 20 (JEP 434) et 21 (JEP 442)
Elle est maintenant dans le package java.lang.foreign du module java.base
API de bas niveau pour de manière simple, sûre et efficace :
• Accéder à des données en mémoire hors du tas (off heap memory)
Alternative à certaines fonctionnalités
De java.nio.ByteBuffer (pas performante mais sûre)
Et sun.misc.Unsafe (non standard)
• Invoquer des fonctions natives
Une future alternative à l’API JNI présente depuis Java 1.1
60. DEVOXX FRANCE 2024
Sciam
60
Foreign Function & Memory API (Third Preview)
Exemple Java 21 sous Windows
public class DialogFFM {
public static void main(String[] args) {
try {
System.loadLibrary("user32");
Optional<MemorySegment> msgBoxFunction = SymbolLookup.loaderLookup().find("MessageBoxA");
FunctionDescriptor msgBoxFunctionDesc = FunctionDescriptor.of(JAVA_INT, ADDRESS, ADDRESS, ADDRESS, JAVA_INT);
Linker linker = Linker.nativeLinker();
MethodHandle methodHandle = linker.downcallHandle(msgBoxFunction.get(), msgBoxFunctionDesc);
try (Arena offHeap = Arena.ofConfined()) {
MemorySegment cStringMessage = offHeap.allocateUtf8String("Voulez-vous utiliser Java 21 ?");
MemorySegment cStringTitre = offHeap.allocateUtf8String("Confirmation");
int bouton = (int) methodHandle.invoke(NULL, cStringMessage, cStringTitre, 36);
}
} catch (Throwable t) {
t.printStackTrace();
}
}
}
61. DEVOXX FRANCE 2024
Sciam
61
Vector API (Sixth Incubator)
Exprimer des calculs vectoriels
Qui, au moment de l'exécution, sont systématiquement compilés
Avec les meilleures instructions vectorielles possibles sur l’architectures CPU
Les SIMD sur les CPU supportées : x64 (SSE et AVX) et AArch64 (Neon)
Single Instruction, Multiple Data
Traiter en parallèle un tableau de données, sans threads
Pour appliquer une même opération sur plusieurs valeurs traitées
En un seul cycle de traitement CPU
En incubation en Java 16 (JEP 338), 17 (JEP 414), 18 (JEP 417),
19 (JEP 426), 20 (JEP 438) et 21 (JEP 448)
Dans le module jdk.incubator.vector
62. DEVOXX FRANCE 2024
Sciam
62
Vector API (Sixth Incubator)
API plutôt de bas niveau, verbeuse, dépendant partiellement du CPU
Mais qui peut offrir de meilleures performances que le code scalaire équivalent
Exemple Java 21
static float[] calculerScalaire(float[] a, float[] b) {
float[] c = new float[a.length];
for (int i = 0 ; i < a.length ; i++) {
c[i] = a[i] * a[i] - b[i] * b[i];
}
return c;
}
static final VectorSpecies<Float> SPECIES =
FloatVector.SPECIES_PREFERRED;
static float[] calculerVectoriel(float[] a, float[] b) {
float[] c = new float[a.length];
int i = 0;
for (; i < SPECIES.loopBound(a.length) ; i += SPECIES.length()) {
var va = FloatVector.fromArray(SPECIES, a, i);
var vb = FloatVector.fromArray(SPECIES, b, i);
var vr = va.mul(va).sub(vb.mul(vb));
vr.intoArray(c, i);
}
for (; i < a.length; i++) {
c[i] = a[i] * a[i] - b[i] * b[i];
}
return c;
}
64. DEVOXX FRANCE 2024
Sciam
64
Conclusion
Java poursuit son évolution en respectant son modèle de releases
La syntaxe, particulièrement le pattern matching
Java 21 proposent des fonctionnalités concernant
N’hésitez pas à télécharger un JDK 21
Cela permettra à Java de rester pertinent aujourd’hui et demain
La programmation parallèle et concurrente
Une meilleure utilisation du matériel moderne
Pour utiliser cette version LTS du JDK