La dernière révision de Java introduit une syntaxe utile pour les enregistrements, entre autres améliorations.

Le monde de la programmation Java évolue constamment, vous obligeant à rester à jour pour exceller dans votre métier.

Java 21 apporte une vague d'améliorations passionnantes qui révolutionnent votre approche de la concurrence, des opérations de collecte et de l'utilisation des 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 d'événements ou de verrous à débloquer, entrave les performances globales.

Dans le passé, résoudre ce problème impliquait d'utiliser des constructions telles que ComplétableFutur ou cadres réactifs, ce qui entraînait un code alambiqué difficile à comprendre et à maintenir.

Heureusement, Java 19 a introduit les threads virtuels en tant que fonctionnalité d'aperçu, que Java 21 a affiné et solidifié via la proposition d'amélioration JDK 444.

instagram viewer

Les threads virtuels offrent une alternative très prometteuse, vous permettant de relever plus efficacement les défis d'évolutivité. Cela permet d'améliorer les performances et la réactivité des applications serveur.

Les collections séquencées sont plus utilisables

Traditionnellement, utiliser des listes chaînées dans votre programmation Java a nécessité un code assez verbeux. Par exemple, pour récupérer le dernier élément, vous devez utiliser cette approche fastidieuse :

var dernier = list.get (list.size() - 1);

Cependant, Java 21 introduit une alternative concise et élégante :

var dernier = liste.getLast();

De même, accéder au premier élément d'un LinkedHashSet nécessite un détour :

var premier = linkedHashSet.iterator().next();

Mais avec Java 21, cette tâche devient beaucoup plus simple :

var premier = liéHashSet.getFirst();

Vous pouvez également accéder au dernier élément d'un LinkedHashSet en utilisant le nouveau obtenirDernier méthode qui évite d'itérer dans tout l'ensemble.

Ces améliorations des collections séquencées améliorent non seulement la lisibilité du code, mais rationalisent également la récupération des éléments, rendant la programmation Java plus efficace et conviviale pour les développeurs.

Enregistrez des modèles pour plus de commodité

Les modèles d'enregistrement, introduits en tant que fonctionnalité d'aperçu dans Java 19, offrent un mécanisme pratique pour accéder aux champs d'un enregistrement dans Java sans avoir besoin de conversions explicites ou de méthodes d'accès.

Ils sont en synergie avec Correspondance de modèle pour instanceof et Correspondance de modèle pour le commutateur, simplifiant considérablement le code et améliorant la lisibilité globale.

Voici une illustration de ce concept, avec un simple enregistrement nommé Position:

public enregistrer Position(entier X, entier y){}

Auparavant, effectuer différentes actions en fonction de la classe d'un objet nécessitait l'utilisation de Correspondance de modèle pour instanceof, comme illustré dans l'extrait de code suivant :

publicannulerimprimer(Objet o){
si (o exemple de Poste p) {
 System.out.printf("o est une position: %d/%d%n", p.x(), p.y());
 } autresi (o exemple de Chaîne s) {
 System.out.printf("o est une chaîne: %s%n", s);
 } autre {
 System.out.printf("o est autre chose: %s%n", o);
 }
}

Avec Modèles d'enregistrement, vous pouvez désormais faire correspondre directement un modèle d'enregistrement tel que Position (int x, int y) au lieu d'utiliser le Poste p modèle. Cela vous permet d'accéder aux variables X et y directement dans le code, éliminant le besoin de p.x() et p.y():

publicannulerimprimer(Objet o){
si (o exemple dePosition(entier X, entier y)) {
 System.out.printf("o est une position: %d/%d%n", x, y);
 } autresi (o exemple de Chaîne s) {
 System.out.printf("o est une chaîne: %s%n", s);
 } autre {
 System.out.printf("o est autre chose: %s%n", o);
 }
}

De plus, vous pouvez utiliser Modèles d'enregistrement en collaboration avec Correspondance de modèle pour le commutateur, pour simplifier davantage votre code :

publicannulerimprimer(Objet o){
changer (o) {
casPosition(entier X, entier y) -> System.out.printf("o est une position: %d/%d%n", x, y);
cas Chaîne s -> System.out.printf("o est une chaîne: %s%n", s);
défaut - > System.out.printf("o est autre chose: %s%n", o);
 }
}

Modèles d'enregistrement imbriqués vous permettent de faire correspondre des enregistrements dont les champs sont eux-mêmes des enregistrements. Par exemple, considérons un enregistrement nommé Chemin qui comprend un depuis et pour position:

public enregistrer Chemin(Position de, Position à){}

En utilisant des modèles d'enregistrement, en imprimant un Chemin l'objet devient plus concis :

publicannulerimprimer(Objet o){
changer (o) {
casChemin(Position de, Position à) -> System.out.printf("o est un chemin: %d/%d -> %d/%d%n", de.x(), depuis.y(), pour.X(), pour.y());
// autres cas
 }
}

Avec l'aide de Modèles d'enregistrement, la gestion des enregistrements avec des champs de types différents devient plus évidente et lisible. Supposons que vous ayez modifié des enregistrements, Position2D et Position3D, où Positionest une interface Java qui implémentent tous les deux :

public scellé interfacePositionpermisPosition2D, Position3D{}
public enregistrer Position2D(entier X, entier y) met en œuvre Position {}
public enregistrer Position3D(entier X, entier y, entier z) met en œuvre Position {}
public record Chemin < P étend la position > (P de, P à) {}

Pour différencier le comportement d'impression des chemins 2D et 3D, vous pouvez utiliser des modèles d'enregistrement :

publicannulerimprimer(Objet o){
changer (o) {
casChemin(Position2D de, Position2D à) -> System.out.printf("o est un chemin 2D: %d/%d -> %d/%d%n", de.x(), depuis.y(), pour.X(), pour.y());
casChemin(Position3D de, Position3D à) -> System.out.printf("o est un chemin 3D: %d/%d/%d -> %d/%d/%d%n", de.x(), depuis.y(), depuis.z(), pour.X(), pour.y(), pour.z());
// autres cas 
 }
}

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 divers.

Déverrouillez de nouvelles possibilités avec Java 21

Java 21 introduit une multitude 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.

Rester à jour avec les dernières fonctionnalités du langage et les frameworks Java vous permet de maintenir un code efficace et maintenable, vous assurant de rester à l'avant-garde de la programmation Java.