Le monde de la programmation Java est en constante évolution, ce qui vous oblige à rester à jour pour exceller dans votre métier.
Java 21 apporte une vague d’améliorations passionnantes qui révolutionnent la façon dont vous abordez la concurrence, les opérations de collection et le travail avec les enregistrements.
Présentation des threads virtuels
La mise à l’échelle des applications serveur a toujours présenté des défis, les threads devenant souvent des goulots d’étranglement. Le nombre limité de threads, combiné à l’attente fréquente du déblocage d’événements ou de verrous, nuit aux performances globales.
Dans le passé, la résolution de ce problème impliquait l’utilisation de constructions telles que CompletableFuture ou cadres réactifsqui se traduisait par un code alambiqué difficile à comprendre et à maintenir.
Heureusement, Java 19 a introduit les threads virtuels en tant que fonctionnalité de prévisualisation, que Java 21 a affiné et solidifié via la proposition d’amélioration 444 du JDK.
Les threads virtuels constituent une alternative très prometteuse, qui vous permet de relever plus efficacement les défis de l’évolutivité. Cela permet d’améliorer les performances et la réactivité des applications serveur.
Les collections séquencées sont plus faciles à utiliser
Traditionnellement, l’utilisation de listes chaînées dans votre programmation Java nécessite un code assez verbeux. Par exemple, pour récupérer le dernier élément, vous devez utiliser cette approche fastidieuse :
var last = list.get(list.size() - 1); Cependant, Java 21 introduit une alternative concise et élégante :
var last = list.getLast(); De même, l’accès au premier élément d’un LinkedHashSet nécessite un chemin détourné :
var first = linkedHashSet.iterator().next(); Mais avec Java 21, cette tâche devient beaucoup plus simple :
var first = linkedHashSet.getFirst(); Vous pouvez également accéder au dernier élément d’un LinkedHashSet à l’aide de la nouvelle fonction getLast qui évite d’itérer sur l’ensemble du jeu.
Ces améliorations apportées aux collections séquencées permettent non seulement d’améliorer la lisibilité du code, mais aussi de rationaliser la récupération des éléments, ce qui rend la programmation Java plus efficace et plus conviviale pour les développeurs.
Des modèles d’enregistrement pour plus de commodité
Les Record Patterns, introduits en avant-première dans Java 19, offrent un mécanisme pratique pour accéder aux champs d’un enregistrement en Java sans avoir recours à des casts explicites ou à des méthodes d’accès.
Ils sont en synergie avec Correspondance de motifs pour instanceof et Correspondance de motifs pour l’interrupteurce qui simplifie considérablement le code et améliore la lisibilité générale.
Voici une illustration de ce concept, avec un simple enregistrement nommé Position:
public record Position(int x, int y) {} Auparavant, l’exécution de différentes actions basées sur la classe d’un objet nécessitait l’utilisation de la commande Correspondance de motifs pour instanceofcomme le montre l’extrait de code suivant :
public void print(Object o) {
if (o instanceof Position p) {
System.out.printf("o is a position: %d/%d%n", p.x(), p.y());
} else if (o instanceof String s) {
System.out.printf("o is a string: %s%n", s);
} else {
System.out.printf("o is something else: %s%n", o);
}
} Avec Modèles de disquesvous pouvez maintenant faire correspondre directement un motif d’enregistrement tel que Position (int x, int y) au lieu d’utiliser la fonction Position p modèle. Cela vous permet d’accéder aux variables x et y directement dans le code, éliminant ainsi le besoin de p.x() et p.y():
public void print(Object o) {
if (o instanceof Position(int x, int y)) {
System.out.printf("o is a position: %d/%d%n", x, y);
} else if (o instanceof String s) {
System.out.printf("o is a string: %s%n", s);
} else {
System.out.printf("o is something else: %s%n", o);
}
} De plus, vous pouvez utiliser Modèles d’enregistrement en liaison avec Correspondance de motifs pour les commutateurspour simplifier davantage votre code :
public void print(Object o) {
switch (o) {
case Position(int x, int y) - > System.out.printf("o is a position: %d/%d%n", x, y);
case String s - > System.out.printf("o is a string: %s%n", s);
default - > System.out.printf("o is something else: %s%n", o);
}
} Modèles d’enregistrements imbriqués vous permettent de faire correspondre des enregistrements dont les rubriques sont elles-mêmes des enregistrements. Par exemple, considérons un enregistrement nommé Chemin d’accès qui comprend un de et à position :
public record Path(Position from, Position to) {} En utilisant des motifs d’enregistrement, l’impression d’un Chemin devient plus concis :
public void print(Object o) {
switch (o) {
case Path(Position from, Position to) - > System.out.printf("o is a path: %d/%d -> %d/%d%n", from.x(), from.y(), to.x(), to.y());
// other cases
}
} A l’aide de Modèles d’enregistrementsla gestion des enregistrements comportant des champs de types différents devient plus évidente et plus lisible. Supposons que vous ayez modifié des enregistrements, Position2D et Position3Doù Position est une interface Java que tous deux mettent en œuvre :
public sealed interface Position permits Position2D, Position3D {}
public record Position2D(int x, int y) implements Position {}
public record Position3D(int x, int y, int z) implements Position {}
public record Path < P extends Position > (P from, P to) {} Pour différencier le comportement d’impression des chemins 2D et 3D, vous pouvez utiliser des motifs d’enregistrement :
public void print(Object o) {
switch (o) {
case Path(Position2D from, Position2D to) - > System.out.printf("o is a 2D path: %d/%d -> %d/%d%n", from.x(), from.y(), to.x(), to.y());
case Path(Position3D from, Position3D to) - > System.out.printf("o is a 3D path: %d/%d/%d -> %d/%d/%d%n", from.x(), from.y(), from.z(), to.x(), to.y(), to.z());
// other cases
}
} Les modèles d’enregistrement réduisent considérablement la verbosité et améliorent la lisibilité du code lorsqu’il s’agit d’enregistrements contenant des champs de types différents.
Débloquer de nouvelles possibilités avec Java 21
Java 21 introduit une série de fonctionnalités puissantes qui augmentent les capacités du langage de programmation Java. En adoptant ces améliorations, vous pouvez rationaliser vos processus de développement et ouvrir de nouvelles possibilités pour vos applications.
En restant informé des dernières fonctionnalités du langage et des frameworks Java, vous êtes en mesure de maintenir un code efficace et facile à entretenir, ce qui vous permet de rester à l’avant-garde de la programmation Java.
