Java 10 est la version la plus rapide de Java de son histoire de 23 ans. Java a été critiqué pour sa croissance lente et son évolution, mais Java 10 a brisé ce concept. Java 10 est une version avec de nombreux changements futuristes, dont la portée et l’impact peuvent ne pas être évidents mais sont considérables. Dans cet article, nous discuterons des différentes fonctionnalités ajoutées dans la version Java 10. Avant cela, examinons quelques changements introduits dans le modèle de publication de Java.
Modèle de support à long terme
À partir de 2017, Oracle et la communauté Java ont annoncé leur passage à une cadence de 6 mois pour Java. Il est passé à un modèle de support à long terme (LTS) pour les produits Oracle Java SE. Qu’est-ce que cela signifie? Les versions LTS des produits offriront un support premier et soutenu par Oracle et seront ciblées tous les 3 ans. Chaque version de Java est modélisée après une ou deux fonctionnalités majeures, ces fonctionnalités entraînent la version. Tout obstacle reporte la version et la retarde sur le marché. Project Jigsaw était une fonctionnalité majeure de Java 9, elle a repoussé les dates de sortie à plusieurs reprises et la version a été retardée de plus de 1,5 ans. La version à une cadence de 6 mois suivra un train de sortie. Le train de sortie aura un calendrier tous les 6 mois. Les fonctionnalités qui sont retenues sont intégrées au train ; sinon, elles attendent le prochain train prévu.
Oracle JDK vs Open JDK
Pour être plus convivial pour les développeurs, la communauté Oracle et Java promeut désormais les binaires OpenJDK comme JDK principal à l’avenir. C’est un grand soulagement par rapport aux premiers jours, où les binaires JDK étaient propriétaires et sous licence Oracle, ce qui comportait diverses restrictions en matière de redistribution. Oracle continuera cependant de produire son JDK, mais uniquement pour les versions à long terme. Il s’agit d’un mouvement vers une plus grande convivialité pour le cloud et les conteneurs, car les binaires OpenJDK peuvent être distribués dans le cadre d’un conteneur. Qu’est-ce que cela signifie? Les binaires OpenJDK seront publiés tous les 6 mois, tandis que les binaires Oracle JDK seront publiés tous les 3 ans (version LTS). Quels binaires JDK seront adoptés? Les grandes organisations mettent du temps à passer d’une version à l’autre ; elles s’accrochent à la version jusqu’à ce qu’elles le puissent. L’adoption industrielle de Java 6 était supérieure à celle de Java 7, puis l’industrie passe progressivement à Java 8. À mon avis, les versions LTS seront les plus favorisées par les entreprises. Cependant, qu’il s’agisse de la version LTS d’Oracle JDK ou d’Open JDK reste à savoir, en partie parce qu’il se passe beaucoup de choses dans l’espace cloud. Java 9 et 10 sont des versions non-LTS. Java 11, qui est prévu pour septembre 2018, sera une version LTS.
Les fonctionnalités de Java 10
Jetons un coup d’œil aux fonctionnalités disponibles dans Java 10.
Avec l’adoption du cycle de sortie basé sur le temps, Oracle a modifié le schéma de chaîne de version de la plateforme Java SE et du JDK, ainsi que les informations de version associées, pour les modèles de sortie basés sur le temps présents et futurs. Le nouveau schéma du numéro de version est : $FEATURE.$INTERIM.$UPDATE.$PATCH $FEATURE: le compteur sera incrémenté tous les 6 mois et sera basé sur les versions de publication des fonctionnalités, par exemple : JDK 10, JDK 11. $INTERIM: le compteur sera incrémenté pour les versions non fonctionnelles qui contiennent des corrections de bogues compatibles et des améliorations mais pas de modifications incompatibles. En général, cela sera à zéro, car il n’y aura pas de version intérimaire dans une période de six mois. Cela est conservé pour une révision future du modèle de sortie. $UPDATE: le compteur sera incrémenté pour les versions de mise à jour compatibles qui corrigent les problèmes de sécurité, les régressions et les bogues dans les nouvelles fonctionnalités. Ceci est mis à jour un mois après la publication de la fonctionnalité et tous les 3 mois par la suite. La version d’avril 2018 est JDK 10.0.1, la version de juillet est JDK 10.0.2, et ainsi de suite. $PATCH: le compteur sera incrémenté pour une version d’urgence visant à corriger un problème critique. De nouvelles API ont été ajoutées pour obtenir ces valeurs de compteur de manière programmatique. Jetons un coup d’œil;
Version version = Runtime.version();
version.feature();
version.interim();
version.update();
version.patch();
Maintenant, jetons un coup d’œil au lanceur Java qui renvoie les informations de version :
$ java -version
java version "10" 2018-03-20
Java(TM) SE Runtime Environment 18.3 (build 10+46)
Java HotSpot(TM) 64-Bit Server VM 18.3 (build 10+46, mixed mode)
Le format du numéro de version est « 10 » car il n’y a pas d’autre compteur autre que zéro. La date de publication est ajoutée. 18.3 peut être lu comme l’année 2018 et le 3ème mois, la construction 10+46 est la 46ème construction pour la version 10. Pour une construction hypothétique 93 de JDK 10.0.1, la construction sera 10.0.1+939. ### Inférence de type de variable local (JEP 286)
Le type d’inférence de variable local est la plus grande nouvelle fonctionnalité de Java 10 pour les développeurs. Il ajoute une inférence de type aux déclarations de variables locales avec des initialiseurs. L’inférence de type local ne peut être utilisée que dans les scénarios suivants :
- Limitée uniquement aux variables locales avec initialiseur
- Indices de la boucle for améliorée ou indices
- Locale déclarée dans une boucle for
Jetons un coup d’œil à son utilisation :
var numbers = List.of(1, 2, 3, 4, 5); // inferred value ArrayList
// Indice de la boucle for améliorée
for (var number : numbers) {
System.out.println(number);
}
// Variable locale déclarée dans une boucle
for (var i = 0; i < numbers.size(); i++) {
System.out.println(numbers.get(i));
}
Vous pouvez en savoir plus à ce sujet dans notre publication exclusive sur l’inférence de type de variable locale Java 10.
Cette fonctionnalité permet au compilateur JIT basé sur Java, Graal, d’être utilisé comme compilateur JIT expérimental sur la plateforme Linux/x64. C’est de loin l’inclusion la plus futuriste dans la liste des fonctionnalités de Java 10. Graal a été introduit dans Java 9. C’est une alternative au compilateur JIT auquel nous étions habitués. C’est un plugin pour le JVM, ce qui signifie que le compilateur JIT n’est pas lié au JVM et peut être dynamiquement branché et remplacé par un autre plugin conforme à JVMCI (Java-Level JVM Compiler Interface). Il apporte également la compilation Ahead of Time (AOT) dans le monde Java. Il prend également en charge l’interprétation des langages polyglottes. « Un compilateur Just in Time basé sur Java écrit en Java pour convertir le bytecode Java en code machine. » Est-ce confus ? Si le JVM est écrit en Java, alors n’avez-vous pas besoin d’un JVM pour exécuter le JVM ? Le JVM peut être compilé AOT, puis le compilateur JIT peut être utilisé à l’intérieur du JVM pour améliorer les performances grâce à une optimisation de code en direct. Graal est une réécriture complète du compilateur JIT en Java à partir de zéro. Le compilateur JIT précédent était écrit en C++. Il est considéré comme l’une des dernières étapes de l’évolution de tout langage de programmation. Vous pouvez passer à Graal avec les paramètres JVM suivants :
-XX:+UnlockExperimentalVMOptions -XX:+UseJVMCICompiler
Vous pouvez en savoir plus sur Graal à partir de la présentation de Chris Seaton.
Cette fonctionnalité aide à améliorer l’empreinte de démarrage, étend la fonctionnalité de partage de données de classe existante (« CDS ») pour permettre aux classes d’application d’être placées dans l’archive partagée. JVM, lors du démarrage, effectue certaines étapes préliminaires, dont le chargement des classes en mémoire. S’il y a plusieurs fichiers JAR contenant plusieurs classes, le retard lors de la première demande est clairement visible. Cela pose problème avec l’architecture sans serveur, où le temps de démarrage est critique. Afin de réduire le temps de démarrage de l’application, le partage de données de classe d’application peut être utilisé. L’idée est de réduire l’empreinte en partageant les métadonnées de classe communes entre différents processus Java. Cela peut être réalisé en suivant les 3 étapes suivantes :
– Détermination des classes à archiver : Utilisez le lanceur Java pour créer une liste de fichiers à archiver, cela peut être réalisé en utilisant les paramètres suivants :
$java -Xshare:off -XX:+UseAppCDS -XX:DumpLoadedClassList=hello.lst -cp hello.jar HelloWorld
Création de l’archive AppCDS : Utilisez le lanceur Java pour créer l’archive de la liste des fichiers à utiliser pour l’application CDS, cela peut être réalisé en utilisant les paramètres suivants :
$java -Xshare:dump -XX:+UseAppCDS -XX:SharedClassListFile=hello.lst -XX:SharedArchiveFile=hello.jsa -cp hello.jar
Utilisation de l’archive AppCDS : Utilisez le lanceur Java avec les paramètres suivants pour utiliser l’application CDS.
$java -Xshare:on -XX:+UseAppCDS -XX:SharedArchiveFile=hello.jsa -cp hello.jar HelloWorld
G1 collecteur de déchets est devenu le défaut dans JDK 9. Le collecteur de déchets G1 évite toute collecte de déchets complète, mais lorsque les threads concurrents pour la collecte ne peuvent pas réanimer la mémoire assez rapidement, l’expérience des utilisateurs est affectée. Ce changement améliore la latence maximale de G1 en cas de pire scénario en rendant la collecte complète parallèle. L’algorithme de marquage-balayage-compactage du collecteur G1 est parallélisé dans le cadre de ce changement et sera déclenché lorsque les threads concurrents pour la collecte ne peuvent pas réanimer la mémoire assez rapidement.25. ### Interface de collecteur de déchets (JEP 304)
Cette JEP est un changement futuriste. Elle améliore l’isolation du code des différents collecteurs de déchets en introduisant une interface de collecteur de déchets commune. Ce changement offre une meilleure modularité au code de collecte de déchets interne. Il aidera à l’avenir à ajouter de nouveaux collecteurs de déchets sans changer le code existant, ainsi qu’à supprimer ou à entretenir les collecteurs de déchets précédents.26. ### Extensions supplémentaires de balises de langue Unicode (JEP 314)
Cette fonctionnalité améliore java.util.Locale et les API associées pour mettre en œuvre des extensions Unicode supplémentaires des balises de langue BCP 47. À partir de Java SE 9, les extensions de balises de langue BCP 47 U prises en charge sont « ca » et « nu ». Cette JEP ajoutera la prise en charge des extensions supplémentaires suivantes:
- cu (type de devise)
- fw (premier jour de la semaine)
- rg (remplacement de région)
- tz (fuseau horaire)
Afin de prendre en charge ces extensions supplémentaires, des modifications sont apportées à diverses API pour fournir des informations basées sur U ou des extensions supplémentaires.
java.text.DateFormat::get*Instance
java.text.DateFormatSymbols::getInstance
java.text.DecimalFormatSymbols::getInstance
java.text.NumberFormat::get*Instance
java.time.format.DateTimeFormatter::localizedBy
java.time.format.DateTimeFormatterBuilder::getLocalizedDateTimePattern
java.time.format.DecimalStyle::of
java.time.temporal.WeekFields::of
java.util.Calendar::{getFirstDayOfWeek,getMinimalDaysInWeek}
java.util.Currency::getInstance
java.util.Locale::getDisplayName
java.util.spi.LocaleNameProvider
Afin de promouvoir OpenJDK et de le rendre plus attrayant pour les utilisateurs de la communauté, cette fonctionnalité fournit un ensemble par défaut de certificats d’autorité de certification (CA) racine dans le JDK. Cela signifiera également que les binaires Oracle & Open JDK seront fonctionnellement identiques. Des composants de sécurité critiques tels que TLS fonctionneront par défaut dans les versions OpenJDK à venir. ### Handshakes Thread-Local (JEP 312)
Il s’agit d’une fonctionnalité interne de la JVM visant à améliorer les performances. Une opération de poignée de main est un rappel qui est exécuté pour chaque JavaThread pendant que ce thread est dans un état de point de sûreté. Le rappel est exécuté soit par le thread lui-même, soit par le thread VM tout en maintenant le thread dans un état bloqué. Cette fonctionnalité fournit un moyen d’exécuter un rappel sur des threads sans effectuer de point de sûreté VM global. Rendre possible et bon marché l’arrêt des threads individuels et non seulement tous les threads ou aucun. ### Allocation de tas sur des dispositifs de mémoire alternatifs (JEP 316)
Les applications sont devenues gourmandes en mémoire, on observe une augmentation des applications cloud-native, des bases de données en mémoire et des applications de streaming. Afin de répondre à ces services, différentes architectures de mémoire sont disponibles. Cette fonctionnalité améliore la capacité de HotSpot VM à allouer le tas d’objets Java sur un périphérique mémoire alternatif, tel qu’un NV-DIMM, spécifié par l’utilisateur. Cette JEP cible des dispositifs mémoire alternatifs ayant les mêmes sémantiques que la DRAM, y compris les sémantiques des opérations atomiques, et peuvent donc être utilisés à la place de la DRAM pour le tas d’objets sans aucun changement dans le code d’application existant.32. ### Suppression de l’outil de génération d’en-têtes natifs – javah (JEP 313)
Il s’agit d’un changement d’entretien visant à supprimer l’outil javah de JDK. La fonctionnalité de l’outil est ajoutée dans javac dans JDK 8, ce qui permet d’écrire des fichiers d’en-tête natifs au moment de la compilation, rendant javah inutile.35. ### Consolidation de la forêt JDK en un seul référentiel (JEP 296)
Au fil des ans, il y a eu divers référentiels Mercurial pour le code source du JDK. Différents référentiels offrent certains avantages, mais ils présentaient également divers inconvénients opérationnels. Dans le cadre de ce changement, de nombreux référentiels de la forêt JDK sont regroupés en un seul référentiel afin de simplifier et rationaliser le développement.36. ### Modifications de l’API
Java 10 a ajouté et supprimé (Oui, ce n’est pas une faute de frappe) des API. Java 9 a introduit une dépréciation améliorée où certaines API ont été marquées pour être supprimées dans les versions futures. API Supprimées: Vous pouvez trouver les API supprimées ici. API Ajoutées: 73 nouvelles API ont été ajoutées dans Java 10. Vous pouvez trouver les API ajoutées ainsi que la comparaison ici. Passons en revue quelques ajouts:
- Les interfaces List, Map et Set ont été ajoutées avec une méthode statique copyOf(Collection). Elle renvoie une List, Map ou Set non modifiable contenant les entrées fournies. Pour une List, si la List donnée est modifiée par la suite, la List retournée ne reflétera pas ces modifications.
- Optional et ses variations primitives obtiennent une méthode orElseThrow(). C’est exactement la même chose que get(), cependant la documentation Java indique que c’est une alternative préférée à get()
- La classe Collectors obtient diverses méthodes pour collecter des collections non modifiables (Set, List, Map)
List actors = new ArrayList<>();
actors.add("Jack Nicholson");
actors.add("Marlon Brando");
System.out.println(actors); // prints [Jack Nicholson, Marlon Brando]
// Nouvelle API ajoutée - Crée une List non modifiable à partir d'une List.
List copyOfActors = List.copyOf(actors);
System.out.println(copyOfActors); // prints [Jack Nicholson, Marlon Brando]
// copyOfActors.add("Robert De Niro"); Générera une
// UnsupportedOperationException
actors.add("Robert De Niro");
System.out.println(actors);// prints [Jack Nicholson, Marlon Brando, Robert De Niro]
System.out.println(copyOfActors); // prints [Jack Nicholson, Marlon Brando]
String str = "";
Optional name = Optional.ofNullable(str);
// Nouvelle API ajoutée - est l'option préférée à la méthode get()
name.orElseThrow(); // same as name.get()
// Nouvelle API ajoutée - Collectors.toUnmodifiableList
List collect = actors.stream().collect(Collectors.toUnmodifiableList());
// collect.add("Tom Hanks"); // Générera une
// UnsupportedOperationException
Conclusion
Dans cet article, nous avons parcouru les différentes nouvelles fonctionnalités ajoutées à Java 10. Si vous pensez que quelque chose d’important a été omis ici, veuillez nous le faire savoir dans les commentaires. Comme d’habitude, vous pouvez consulter le code complet sur GitHub ici.
Source:
https://www.digitalocean.com/community/tutorials/java-10-features