Fonctionnalités de Java 9 avec des Exemples

Java 9 est une version majeure et elle nous a apporté de nombreuses fonctionnalités pour les développeurs. Dans cet article, nous examinerons en détail les fonctionnalités de Java 9.

Java 10 a été publié, pour un aperçu complet de la version 10 de Java, consultez les fonctionnalités de Java 10.

Les fonctionnalités de Java 9

Certaines des fonctionnalités importantes de Java 9 sont :

1. Java 9 REPL (JShell)
2. Méthodes de fabrique pour les listes immuables, les ensembles, les cartes et les entrées de carte immuables
3. Méthodes privées dans les interfaces
4. Système de modules Java 9
5. Améliorations de l’API Process
6. Amélioration de l’instruction Try With Resources
7. Améliorations de l’API CompletableFuture
8. Flux réactifs
9. Opérateur diamant pour les classes internes anonymes
10. Améliorations de la classe Optionnelle
11. Améliorations de l’API Stream
12. Annotation @Deprecated améliorée
13. Client HTTP 2
14. API d’image multi-résolution
15. Fonctionnalités diverses de Java 9

Oracle Corporation s’apprête à publier Java SE 9 vers la fin mars 2017. Dans cet article, je vais discuter brièvement des « Fonctionnalités de Java 9 » avec quelques exemples.

REPL Java 9 (JShell)

Oracle Corp a introduit un nouvel outil appelé « jshell ». Il signifie Java Shell et est également connu sous le nom de REPL (Read Evaluate Print Loop). Il est utilisé pour exécuter et tester facilement toutes les constructions Java telles que classe, interface, énumération, objet, instructions, etc. Nous pouvons télécharger le logiciel JDK 9 EA (Early Access) à partir de https://jdk9.java.net/download/

G:\>jshell
|  Welcome to JShell -- Version 9-ea
|  For an introduction type: /help intro


jshell> int a = 10
a ==> 10

jshell> System.out.println("a value = " + a )
a value = 10

Si vous souhaitez en savoir plus sur l’outil REPL, veuillez consulter Principes de base du REPL Java 9 (Partie 1) et Fonctionnalités du REPL Java 9 (Partie 2).

Méthodes de fabrique pour Listes, Ensembles, Cartes et Entrées de Cartes Immutables

Oracle Corp a introduit quelques méthodes de fabrique pratiques pour créer des objets de Liste, Ensemble, Carte et Entrée de Carte immuables. Ces méthodes utilitaires sont utilisées pour créer des objets de Collection vides ou non vides. Dans Java SE 8 et les versions antérieures, nous pouvons utiliser les méthodes utilitaires de la classe Collections comme unmodifiableXXX pour créer des objets de Collection immuables. Par exemple, si nous voulons créer une Liste immuable, alors nous pouvons utiliser la méthode Collections.unmodifiableList. Cependant, ces méthodes Collections.unmodifiableXXX sont une approche fastidieuse et verbeuse. Pour surmonter ces inconvénients, Oracle Corp a ajouté quelques méthodes utilitaires aux interfaces List, Set et Map. Les interfaces List et Set ont des méthodes « of() » pour créer une Liste ou un Ensemble immuable vide ou non vide comme indiqué ci-dessous: Exemple de Liste Vide

List immutableList = List.of();

Exemple de Liste Non Vide

List immutableList = List.of("one","two","three");

La Carte a deux ensembles de méthodes: les méthodes of() et les méthodes ofEntries() pour créer respectivement un objet Carte immuable et une Entrée de Carte immuable. Exemple de Carte Vide

jshell> Map emptyImmutableMap = Map.of()
emptyImmutableMap ==> {}

Exemple de Carte Non Vide

jshell> Map nonemptyImmutableMap = Map.of(1, "one", 2, "two", 3, "three")
nonemptyImmutableMap ==> {2=two, 3=three, 1=one}

Si vous souhaitez en savoir plus sur ces méthodes utilitaires, veuillez consulter les liens suivants:

• Méthodes de fabrique Java 9 pour Liste immuable
• Méthodes de fabrique Java 9 pour Ensemble immuable
• Méthodes de fabrique Java 9 pour Map immuable et Map.Entry

Méthodes privées dans les interfaces

En Java 8, nous pouvons fournir une implémentation de méthode dans les interfaces en utilisant des méthodes par défaut et statiques. Cependant, nous ne pouvons pas créer de méthodes privées dans les interfaces. Pour éviter le code redondant et favoriser la réutilisabilité, Oracle Corp va introduire des méthodes privées dans les interfaces Java SE 9. À partir de Java SE 9, nous pouvons également écrire des méthodes privées et privées statiques dans une interface en utilisant le mot-clé ‘private’. Ces méthodes privées sont similaires aux autres méthodes privées de classe, il n’y a pas de différence entre elles.

public interface Card{

  private Long createCardID(){
    // L'implémentation de la méthode se trouve ici.
  }

  private static void displayCardDetails(){
    // L'implémentation de la méthode se trouve ici.
  }

}

Si vous souhaitez en savoir plus sur cette nouvelle fonctionnalité, veuillez consulter ce lien : Méthodes privées Java 9 dans l’interface.

Système de modules Java 9

Une des grandes modifications ou fonctionnalités de Java 9 est le système de modules. Oracle Corp va introduire les fonctionnalités suivantes dans le cadre du Projet Jigsaw.

• JDK modulaire
• Code source Java modulaire
• Images d’exécution modulaires
• Encapsulation des API internes Java
• Système de modules de plate-forme Java

Avant les versions Java SE 9, nous utilisions des JAR monolithiques pour développer des applications Java. Cette architecture présente de nombreuses limitations et inconvénients. Pour éviter tous ces inconvénients, Java SE 9 est livré avec le système de modules. JDK 9 est livré avec 92 modules (pouvant changer dans la version finale). Nous pouvons utiliser les modules JDK et également créer nos propres modules comme indiqué ci-dessous : Exemple de module simple

module com.foo.bar { }

Ici, nous utilisons le mot-clé ‘module’ pour créer un module simple. Chaque module a un nom, du code associé et d’autres ressources. Pour plus de détails sur cette nouvelle architecture et une expérience pratique, veuillez consulter mes tutoriels originaux ici :

• Fondamentaux du système de modules Java 9
• Exemples de modules Java 9 en utilisant l’invite de commandes
• Exemple de module Java 9 Hello World utilisant l’IDE Eclipse

Améliorations de l’API de processus

Java SE 9 arrive avec quelques améliorations dans l’API de processus. Ils ont ajouté quelques nouvelles classes et méthodes pour faciliter le contrôle et la gestion des processus OS. Deux nouvelles interfaces dans l’API de processus :

• java.lang.ProcessHandle
• java.lang.ProcessHandle.Info

Exemple d’API de processus

 ProcessHandle currentProcess = ProcessHandle.current();
 System.out.println("Current Process Id: = " + currentProcess.getPid());

Amélioration de l’instruction Try-With-Resources

Nous savons que Java SE 7 a introduit une nouvelle structure de gestion des exceptions : Try-With-Resources pour gérer automatiquement les ressources. L’objectif principal de cette nouvelle instruction est « Gestion automatique des ressources meilleure ». Java SE 9 va apporter quelques améliorations à cette instruction pour éviter un peu plus de verbiage et améliorer la lisibilité. Exemple Java SE 7

void testARM_Before_Java9() throws IOException{
 BufferedReader reader1 = new BufferedReader(new FileReader("journaldev.txt"));
 try (BufferedReader reader2 = reader1) {
   System.out.println(reader2.readLine());
 }
}

Exemple Java 9

void testARM_Java9() throws IOException{
 BufferedReader reader1 = new BufferedReader(new FileReader("journaldev.txt"));
 try (reader1) {
   System.out.println(reader1.readLine());
 }
}

Pour en savoir plus sur cette nouvelle fonctionnalité, veuillez consulter mon tutoriel original à : Améliorations de Java 9 Try-With-Resources

Améliorations de l’API CompletableFuture

En Java SE 9, Oracle Corp va améliorer l’API CompletableFuture pour résoudre certains problèmes soulevés dans Java SE 8. Ils vont ajouter le support de certains délais et délais d’attente, quelques méthodes utilitaires et une meilleure sous-classification.

Executor exe = CompletableFuture.delayedExecutor(50L, TimeUnit.SECONDS);

Ici, delayedExecutor() est une méthode utilitaire statique utilisée pour retourner un nouveau Executor qui soumet une tâche à l’exécuteur par défaut après le délai donné.

Flux réactifs

De nos jours, la programmation réactive est devenue très populaire dans le développement d’applications pour obtenir de nombreux avantages. Des frameworks tels que Scala, Play, Akka, etc. ont déjà intégré les flux réactifs et en tirent de nombreux avantages. Oracle Corps introduit également une nouvelle API Reactive Streams dans Java SE 9. L’API Reactive Streams de Java SE 9 est un framework de publication/abonnement pour implémenter facilement des applications asynchrones, évolutives et parallèles en utilisant le langage Java. Java SE 9 a introduit les API suivantes pour développer des flux réactifs dans les applications basées sur Java.

• java.util.concurrent.Flow
• java.util.concurrent.Flow.Publisher
• java.util.concurrent.Flow.Subscriber
• java.util.concurrent.Flow.Processor

En savoir plus sur Java 9 Reactive Streams.

Opérateur diamant pour une classe interne anonyme

Nous savons que Java SE 7 a introduit une nouvelle fonctionnalité : l’opérateur diamant pour éviter le code redondant et la verbosité, pour améliorer la lisibilité. Cependant, dans Java SE 8, Oracle Corp (développeur de bibliothèques Java) a constaté certaines limitations dans l’utilisation de l’opérateur diamant avec une classe interne anonyme. Ils ont corrigé ces problèmes et s’apprêtent à les publier dans le cadre de Java 9.

  public List getEmployee(String empid){
     // Code pour obtenir les détails de l'employé à partir du magasin de données
     return new List(emp){ };
  }

Ici, nous utilisons simplement « Liste » sans spécifier le paramètre de type.

Améliorations de la classe Optionnelle

En Java SE 9, Oracle Corp a ajouté quelques nouvelles méthodes utiles à la classe java.util.Optional. Ici, je vais discuter de l’une de ces méthodes avec un exemple simple : la méthode stream. Si une valeur est présente dans l’objet Optional donné, cette méthode stream() renvoie un Stream séquentiel avec cette valeur. Sinon, elle renvoie un Stream vide. Ils ont ajouté la méthode « stream() » pour travailler de manière paresseuse sur les objets Optional comme indiqué ci-dessous :

Stream<Optional> emp = getEmployee(id)
Stream empStream = emp.flatMap(Optional::stream)

Ici, la méthode Optional.stream() est utilisée pour convertir un Stream d’Optional d’objet Employee en un Stream d’Employee afin que nous puissions travailler de manière paresseuse sur ce résultat dans le code résultant. Pour en savoir plus sur cette fonctionnalité avec plus d’exemples et pour lire davantage de nouvelles méthodes ajoutées à la classe Optional, veuillez consulter mon tutoriel original à l’adresse suivante :

Java SE 9 : Améliorations de la classe Optional

Améliorations de l’API Stream

En Java SE 9, Oracle Corp a ajouté quatre nouvelles méthodes utiles à l’interface java.util.Stream. Comme Stream est une interface, toutes ces nouvelles méthodes implémentées sont des méthodes par défaut. Deux d’entre elles sont très importantes : les méthodes dropWhile et takeWhile. Si vous êtes familier avec le langage Scala ou tout langage de programmation fonctionnelle, vous connaîtrez certainement ces méthodes. Ce sont des méthodes très utiles pour écrire du code de style fonctionnel. Parlons ici de la méthode utilitaire takeWhile. Cette takeWhile() prend un prédicat en argument et renvoie un Stream du sous-ensemble des valeurs du Stream donné jusqu’à ce que ce prédicat retourne false pour la première fois. Si la première valeur ne satisfait PAS ce prédicat, elle renvoie simplement un Stream vide.

jshell> Stream.of(1,2,3,4,5,6,7,8,9,10).takeWhile(i -> i < 5 )
                 .forEach(System.out::println);
1
2
3
4

Pour en savoir plus sur les méthodes takeWhile et dropWhile et sur les autres nouvelles méthodes, veuillez consulter mon tutoriel original à l’adresse : Java SE 9 : Améliorations de l’API Stream

Enhanced @Deprecated annotation

En Java SE 8 et les versions antérieures, l’annotation @Deprecated est simplement une interface de marqueur sans aucune méthode. Elle est utilisée pour marquer une API Java qui est une classe, un champ, une méthode, une interface, un constructeur, une énumération, etc. Dans Java SE 9, Oracle Corp a amélioré l’annotation @Deprecated pour fournir plus d’informations sur l’API obsolète et également fournir un Outil pour analyser l’utilisation statique d’API obsolètes dans une application. Ils ont ajouté deux méthodes à cette interface Deprecated : forRemoval et since pour fournir ces informations.

Client HTTP 2

Dans Java SE 9, Oracle Corp s’apprête à publier une nouvelle API client HTTP 2 pour prendre en charge le protocole HTTP/2 et les fonctionnalités WebSocket. Étant donné que l’API client HTTP existante ou legacy présente de nombreux problèmes (comme le support du protocole HTTP/1.1 et l’absence de prise en charge des protocoles HTTP/2 et WebSocket, fonctionne uniquement en mode bloquant et présente de nombreux problèmes de performance), ils remplacent cette API HttpURLConnection par un nouveau client HTTP. Ils vont introduire une nouvelle API client HTTP 2 dans le package « java.net.http ». Elle prend en charge à la fois les protocoles HTTP/1.1 et HTTP/2. Elle prend en charge à la fois les modes synchrone (mode bloquant) et asynchrone. Elle prend en charge le mode asynchrone en utilisant l’API WebSocket. Vous pouvez consulter cette nouvelle API sur https://download.java.net/java/jdk9/docs/api/java/net/http/package-summary.html Exemple de client HTTP 2

jshell> import java.net.http.*

jshell> import static java.net.http.HttpRequest.*

jshell> import static java.net.http.HttpResponse.*

jshell> URI uri = new URI("https://rams4java.blogspot.co.uk/2016/05/java-news.html")
uri ==> https://rams4java.blogspot.co.uk/2016/05/java-news.html

jshell> HttpResponse response = HttpRequest.create(uri).body(noBody()).GET().response()
response ==> java.net.http.HttpResponseImpl@79efed2d

jshell> System.out.println("Response was " + response.body(asString()))

Veuillez consulter mon tutoriel original sur : Java SE 9 : Client HTTP 2 pour comprendre le protocole HTTP/2 & WebSocket, les avantages de la nouvelle API et les inconvénients de l’ancienne API avec quelques exemples utiles.

API d’image multi-résolution

Dans Java SE 9, Oracle Corp s’apprête à introduire une nouvelle API d’image multi-résolution. L’interface importante de cette API est MultiResolutionImage. Elle est disponible dans le package java.awt.image. MultiResolutionImage encapsule un ensemble d’images avec différentes hauteurs et largeurs (c’est-à-dire différentes résolutions) et nous permet de les interroger selon nos besoins.

Fonctionnalités diverses de Java 9

Dans cette section, je vais simplement énumérer quelques fonctionnalités nouvelles de Java SE 9. Je ne dis PAS que ces fonctionnalités sont moins importantes. Elles sont également importantes et utiles à comprendre très bien avec quelques exemples utiles. Pour l’instant, je n’ai pas assez d’informations sur ces fonctionnalités. C’est pourquoi je vais les énumérer ici pour une compréhension brève. Je vais aborder ces fonctionnalités une par une et les ajouter à la section ci-dessus avec une brève discussion et un exemple. Et enfin, écrire un tutoriel séparé plus tard.

• Améliorations du ramasse-miettes (Garbage Collector)
• API de parcours de la pile (Stack-Walking)
• Filtrer les données de sérialisation entrantes
• Obsolète l’API Applet
• Indifier la concaténation de chaînes
• Handles de méthode améliorés
• API et service de journalisation de la plateforme Java
• Chaînes compactes
• API de parsing pour Nashorn
• Recherche Javadoc
• Javadoc HTML5

I will pickup these java 9 features one by one and update them with enough description and examples. That’s all about Java 9 features in brief with examples.