Java est arrivé Quoi de neuf ?

Java 23 est officiellement sorti ! Il s'agit d'une version non LTS (Long Term Support). Même s'il s'agit d'une version de courte durée, Java 23 est livré avec des améliorations intéressantes, des corrections de bugs, ainsi que des fonctionnalités et options supprimées auxquelles vous devrez peut-être prêter attention.

Plongeons dans les nouveautés et comment elles s'appuient sur les fonctionnalités des versions précédentes comme JDK 21 et JDK 22.

Valeurs étendues : s'appuyer sur les aperçus du JDK 22 et du JDK 21

L'une des fonctionnalités les plus attendues du JDK 23 est Scoped Values (Aperçu). Cette fonctionnalité, qui a également été présentée en avant-première dans JDK 22 et JDK 21, simplifie la façon dont les méthodes partagent des données immuables entre les threads et les threads enfants. Dans les versions Java précédentes, la gestion des données locales des threads pouvait être fastidieuse et gourmande en mémoire. Les valeurs définies changent cela en offrant une alternative plus efficace et moins coûteuse.

Qu'est-ce qui est différent dans JDK 23 ? La méthode ScopedValue.callWhere() utilise désormais une nouvelle interface fonctionnelle, ce qui permet au compilateur de déduire plus facilement si une exception vérifiée peut être levée. Cela a également conduit à la suppression de la méthode ScopedValue.getWhere(), rationalisant ainsi davantage l'API.

Il s'agit d'une continuation des améliorations que nous avons constatées dans les versions précédentes, et c'est passionnant de voir les valeurs étendues évoluer pour devenir une fonctionnalité permanente.

Concurrence structurée : un troisième aperçu

Le modèle de concurrence de Java a toujours été puissant mais délicat à gérer. Entrez Structured Concurrency (Aperçu), qui est apparu pour la première fois dans JDK 21 et a maintenant atteint sa troisième préversion dans JDK 23. L'idée ici est de rendre la programmation simultanée plus intuitive en regroupant les tâches connexes exécutées dans différents threads dans un une seule unité de travail. Cela simplifie la gestion des erreurs et améliore la fiabilité des processus d'annulation.

Dans JDK 23, la concurrence structurée reste en version préliminaire, mais elle continue de rendre le code de concurrence plus facile à raisonner et moins sujet aux erreurs. Si vous avez travaillé avec l'aperçu dans JDK 21 ou JDK 22, vous apprécierez la maturité de cette fonctionnalité. Il est désormais mieux équipé pour gérer les problèmes de concurrence courants tels que les fuites de threads, ce qui facilite l'écriture de code multithread fiable.

Corps de constructeur flexibles : évolution depuis le JDK 22

Un autre ajout bienvenu est Corps de constructeur flexibles (Aperçu). Présentée pour la première fois dans le JDK 22 sous la forme « instructions avant super() », cette fonctionnalité permet aux développeurs d'écrire du code d'initialisation avant d'invoquer le constructeur de superclasse. Ce changement apparemment mineur peut rendre la logique du constructeur beaucoup plus claire et empêcher la création d'objets inutiles en cas d'échec de la validation ou d'une autre logique de configuration.

Dans le JDK 22, cette fonctionnalité a été introduite pour donner aux développeurs plus de contrôle sur la logique du constructeur, et le deuxième aperçu du JDK 23 continue d'affiner cette fonctionnalité. En déplaçant la logique d'initialisation avant l'invocation de la superclasse, les développeurs peuvent éviter les méthodes statiques auxiliaires désordonnées et les constructeurs intermédiaires qui encombraient auparavant les bases de code.

Cours implicitement déclarés : la troisième fois est un charme

Pour ceux qui enseignent Java ou écrivent des scripts rapides, les Classes et méthodes d'instance déclarées implicitement ont changé la donne depuis leur introduction dans le JDK 21. Cette fonctionnalité permet aux débutants d'écrire des programmes Java simplifiés sans avoir besoin de comprendre. fonctionnalités de langage complexes dès le début.

Dans JDK 23, cette fonctionnalité bénéficie de quelques mises à niveau supplémentaires. Désormais, les classes implicitement déclarées peuvent importer automatiquement trois méthodes statiques pour de simples E/S de texte, et elles importeront également toutes les classes et interfaces publiques de niveau supérieur du module java.base à la demande. Ces améliorations contribuent à rendre la courbe d’apprentissage encore plus fluide pour les nouveaux arrivants.

Déclarations d'importation de modules : un nouvel aperçu

L'une des nouvelles fonctionnalités d'aperçu du JDK 23 est les Déclarations d'importation de modules. Cette fonctionnalité vous permet d'importer tous les packages exportés par un module avec une seule instruction, simplifiant ainsi la réutilisation des bibliothèques modulaires. C'est particulièrement utile pour les débutants qui n'ont plus besoin de mémoriser où se trouvent les packages dans la hiérarchie, et cela réduit l'encombrement causé par plusieurs déclarations d'importation de types à la demande.

Bien qu'il s'agisse d'une toute nouvelle fonctionnalité du JDK 23, elle s'avère très prometteuse en rendant le système de modules Java plus accessible, en particulier pour ceux qui débutent dans la programmation modulaire.

Commentaires sur la documentation Markdown : une nouvelle ère pour Javadoc

Soyons honnêtes : écrire du JavaDoc avec HTML et les balises @ peut être pénible. Dans JDK 23, la fonctionnalité Commentaires sur la documentation Markdown (aperçu) permet aux développeurs d'écrire de la documentation sur l'API à l'aide de Markdown, ce qui facilite la création de commentaires lisibles et bien formatés.

Bien qu'il s'agisse d'une nouvelle fonctionnalité du JDK 23, c'est quelque chose qui aurait dû être ajouté il y a des années. Markdown est largement utilisé dans les communautés de développeurs, et son introduction dans JavaDoc facilitera grandement la rédaction et la maintenance de la documentation.

Z Garbage Collector (ZGC) : mode générationnel par défaut

Si vous travaillez avec le Z Garbage Collector (ZGC) depuis son introduction dans le JDK 15, vous serez ravi de savoir que dans le JDK 23, ZGC est désormais par défaut générationnel. mode (JEP 474). Ce commutateur améliore les performances des applications en se concentrant sur la collecte fréquente d'objets de courte durée. Bien que le ZGC non générationnel soit obsolète dans cette version, c'est un signe clair que l'approche générationnelle est l'avenir du garbage collection en Java.

Si vous utilisez JDK 22 ou une version antérieure, le passage à JDK 23 devrait apporter des améliorations notables des performances sans trop d'effort de votre part.

API Vector : toujours en incubation, mais plus puissante

L'API Vector, introduite dans JDK 16, permet aux développeurs d'effectuer des calculs vectoriels qui se compilent selon des instructions vectorielles optimales au moment de l'exécution. L'API continue d'évoluer et dans JDK 23, nous voyons le Huitième Incubateur. Cette API est encore en incubation, ce qui signifie qu’elle n’est pas encore une fonctionnalité finalisée, mais elle se rapproche de sa maturité.

Pour les applications critiques en termes de performances, en particulier celles traitant de grands ensembles de données, l'API Vector peut fournir des accélérations considérables. Si vous avez travaillé avec lors d'incubations précédentes (comme JDK 22), vous constaterez qu'il est encore plus stable maintenant, mais il attend toujours que les dernières pièces se mettent en place (probablement liées au projet Valhalla).

Collecteurs de flux : deuxième aperçu

JDK 22 a introduit les Stream Gatherers (aperçu), une fonctionnalité qui ajoute de la flexibilité à l'API Stream en permettant des opérations intermédiaires personnalisées. Dans JDK 23, il est de retour pour un deuxième aperçu. Si vous aimez utiliser des flux pour traiter des données, vous apprécierez la capacité de cette fonctionnalité à transformer les pipelines de données d'une manière qui était auparavant difficile à réaliser.

Les collecteurs de flux étendent la puissance des flux, permettant aux développeurs de gérer facilement des scénarios plus complexes, en particulier lorsqu'ils travaillent avec des flux infinis ou des transformations personnalisées.

API Class-File : deuxième aperçu

Si vous créez des outils qui manipulent des fichiers de classe Java, l'API Class-File (aperçu) du JDK 23 est faite pour vous. Introduite pour la première fois dans JDK 22, cette API fournit un moyen standard d'analyser et de générer des fichiers de classe sans avoir besoin de bibliothèques tierces comme ASM. Le deuxième aperçu du JDK 23 affine cette API, la rendant plus rationalisée et plus facile à utiliser.

Pour les développeurs d'outils, c'est un gros problème. Plus besoin de mettre à jour les bibliothèques à chaque fois que les spécifications JVM changent : Java dispose désormais d'une solution propriétaire.

Conclusion : devriez-vous effectuer une mise à niveau ?

Java 23 n'est peut-être pas une version LTS, mais il regorge de fonctionnalités intéressantes qui s'appuient sur ce que JDK 21 et JDK 22 ont introduit. Des valeurs étendues et de la concurrence structurée à un meilleur garbage collector et des améliorations des flux et des constructeurs, cette version fait avancer le développement Java.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!