JDK 19 a été publié le 20 septembre 2022. Voici les fonctionnalités importantes de Java 19 qui peuvent être utilisées en développement. 

1. Propriétés système pour System.out et System.err-

   Une application Java existante peut être exécutée avec JDK 19. Des points d’interrogation peuvent apparaître sur la console à la place des caractères spéciaux.

   Dans JDK 19, l’encodage par défaut du système d’exploitation est utilisé pour l’impression sur System.out et System.err « Cp1252 » sous Windows. Pour changer la sortie en UTF-8, les options suivantes doivent être ajoutées lors de l’appel de l’application java :

   -Dstdout.encoding=utf8 -Dstderr.encoding=utf8

   Pour éviter d’effectuer cette étape à chaque démarrage du programme, définissez ces paramètres globalement en créant la variable d’environnement suivante :

   _JAVA_OPTIONS="-Dstdout.encoding=utf8 -Dstderr.encoding=utf8"

2. Méthodes pour créer des HashMap préalloués pour les collections -

   Pour créer une taille ArrayList pour un nombre connu d’éléments (par exemple 60), il convient de procéder comme suit :

   List<String> list = new ArrayList<>(60);

   Le tableau sous-jacent à l’ArrayList est alloué directement pour 60 éléments et n’a pas besoin d’être agrandi plusieurs fois pour insérer les 60 éléments.

   De même, afin de pouvoir générer un HashMap comme ci-dessous :

   Map<String, Integer> map = new HashMap<>(60);

   HashMap offre un volume pour 60 entrées car le HashMap est initialisé avec un facteur de charge par défaut de 0,75. Cela signifie que dès que le HashMap est plein à 75 %, il est reconstruit (reindexé) avec une taille doublée, garantissant que les éléments sont répartis aussi uniformément que possible dans les compartiments du HashMap et que le moins de compartiments possible contiennent plus d’un élément.

   Le HashMap initialisé avec une capacité de 60 ne peut contenir que 60 × 0,75 = 45 associations.

   Pour créer un HashMap pour 60 entrées, la capacité doit être calculée en divisant le nombre d’associations par le facteur de charge : 60 ÷ 0,75 = 80.

   Par conséquent, un HashMap pour 60 entrées doit être créé comme suit :

   // pour 60 associations : 60 / 0,75 = 80

   Map<String, Integer> map = new HashMap<>(80);

   Dans JDK 19, on peut écrire :

   Map<String, Integer> map = HashMap.newHashMap(60);

   En examinant attentivement le code source des nouvelles méthodes, on constate qu’elles font la même chose qu’auparavant dans jdk8 :

   public static <K, V> HashMap<K, V> newHashMap(int numMappings) { 
      return new HashMap<>(calculateHashMapCapacity(numMappings));
   } 
   static final float DEFAULT_LOAD_FACTOR = 0.75f; 
   static int calculateHashMapCapacity(int numMappings) { 
      return (int) Math.ceil(numMappings / (double) DEFAULT_LOAD_FACTOR); 
   } 
   La méthode newHashMap() a également été ajoutée à LinkedHashMap et WeakHashMap.

3. Correspondance de motif pour switch-

   Dans Java 17, la « correspondance de motif pour switch » permet d’écrire un code comme le suivant :

   switch (obj) { 
      case String str && str.length() > 5 -> System.out.println(str.toUpperCase()); 
      case String str  -> System.out.println(str.toLowerCase()); 
      case Integer i -> System.out.println(i * i); 
      default -> {} 
   }

   Si un objet appartient à une classe particulière et si celle-ci possède des fonctionnalités supplémentaires, cela peut être vérifié dans une instruction switch.

   Dans Java 19, JDK Enhancement 427 a modifié la syntaxe du « motif gardé ». Au lieu de &&, le nouveau mot-clé doit être utilisé when, qui est un « mot-clé contextuel » et n’a de signification que dans une étiquette de cas.

   1. switch (obj) { 
         case String str when s.length() > 5 -> System.out.println(str.toUpperCase()); 
         case String str                    -> System.out.println(str.toLowerCase()); 
         case Integer i                    -> System.out.println(i * i); 
         default -> {} 
      }

   S’il existe des variables ou des méthodes avec le nom « when » dans l’application, il n’est pas nécessaire de les modifier.

4. Utiliser Object avec switch-
    

   Depuis Java 17, l’original peut être écrit comme une instruction switch :

   private void display(Object object) { 
      switch (object) { 
      case Calculate calci 
          -> System.out.println("object is a calci, x = " + calci.getNumber() + ", y = " + calci.getAge()); 
      // autres cas ... 
     } 
   }

5. Ce qui suit peut également être utilisé dans l’instruction case du switch :

   private void display(Object object) { 
      switch (object) { 
      case Position(int x, int y)  
        -> System.out.println("object is a position, x = " + x + ", y = " + y); 
      // autres cas ... 
     } 
   }

Références – 
https://www.oracle.com/java/technologies/javase/19-relnote-issues.html