Caractéristiques de Java 12

Enfin, le JDK 12, qui fait partie du cycle de sortie semestriel, est là. Il arrive après la dernière version LTS de Java, la version 11. Nous avions longuement discuté des fonctionnalités de Java 11 auparavant. Aujourd’hui, nous allons discuter des fonctionnalités de Java 12 et voir ce qu’il réserve aux développeurs. Java 12 a été lancé le 19 mars 2019. C’est une version Non-LTS. Par conséquent, il n’aura pas de support à long terme.

Fonctionnalités de Java 12

Certaines des fonctionnalités importantes de Java 12 sont ;

1. Changements dans la JVM – JEP 189, JEP 346, JEP 344, et JEP 230.
2. Expressions switch
3. Méthode mismatch() pour les fichiers
4. Formatage compact des nombres
5. Collecteurs de partitionnement dans l’API Stream
6. Nouvelles méthodes pour les chaînes Java – indent(), transform(), describeConstable(), et resolveConstantDesc().
7. JEP 334 : API des constantes JVM
8. JEP 305 : Correspondance de motifs pour instanceof
9. Les littéraux de chaîne brute sont retirés du JDK 12.

Examinons toutes ces fonctionnalités de Java 12 une par une.

Changements dans la JVM

1. JEP 189 – Shenandoah: Un ramasse-miettes à faible temps de pause (expérimental)

RedHat a initié le ramasse-miettes Shenandoah pour réduire les temps de pause du ramasse-miettes. L’idée est d’exécuter le ramasse-miettes en même temps que les threads Java en cours d’exécution. Il vise des pauses courtes, cohérentes et prévisibles, indépendamment de la taille du tas. Ainsi, peu importe si la taille du tas est de 15 Mo ou 15 Go. Il s’agit d’une fonctionnalité expérimentale dans Java 12.

2. JEP 346 – Retour immédiat de la mémoire allouée inutilisée par G1

À partir de Java 12, G1 vérifiera maintenant la mémoire du tas Java pendant l’inactivité de l’application et la restituera au système d’exploitation. Il s’agit d’une mesure préventive pour conserver et utiliser la mémoire libre.

3. JEP 344 : Collections mixtes avortables pour G1

Les améliorations de l’efficacité de G1 incluent la possibilité d’interrompre les collections mixtes de G1 si elles risquent de dépasser l’objectif de pause défini. Cela est réalisé en divisant l’ensemble de collection mixte en obligatoire et facultatif. Ainsi, le collecteur G1 peut prioriser la collecte de l’ensemble obligatoire en premier lieu pour atteindre l’objectif de temps de pause.

4. JEP 230 et 344

Microbenchmark Suite, JEP 230 ajoute une suite de microbenchmarks de base au code source JDK. Cela permet aux développeurs d’exécuter facilement des microbenchmarks existants et d’en créer de nouveaux. One AArch64 Port, Not Two, JEP 344, supprime toutes les sources liées au port arm64 tout en conservant le port ARM 32 bits et le port aarch64 64 bits. Cela permet aux contributeurs de concentrer leurs efforts sur une seule implémentation ARM 64 bits.

5. JEP 341 Default CDS Archives

Cela améliore le processus de construction JDK pour générer une archive de partage de données de classe (CDS), en utilisant la liste de classes par défaut, sur des plates-formes 64 bits. L’objectif est d’améliorer le temps de démarrage. À partir de Java 12, CDS est activé par défaut. Pour exécuter votre programme sans CDS, faites ce qui suit :

java -Xshare:off HelloWorld.java

Maintenant, cela retarderait le temps de démarrage du programme.

Modifications de langue et fonctionnalités

Java 12 a introduit de nombreuses fonctionnalités linguistiques. Regardons-en quelques-unes avec des implémentations.

1. Expressions de commutation (Aperçu)

Java 12 a amélioré les expressions de commutation pour la correspondance de motifs. Introduit dans JEP 325, en tant que fonctionnalité linguistique de prévisualisation, la nouvelle syntaxe est L ->. Voici quelques points à noter concernant les expressions de commutation :

• La nouvelle syntaxe élimine le besoin de l’instruction break pour éviter les débordements.
• Les expressions de commutation ne débordent plus.
• De plus, nous pouvons définir plusieurs constantes dans le même label.
• Le cas default est maintenant obligatoire dans les expressions de commutation.
• break est utilisé dans les expressions de commutation pour renvoyer des valeurs à partir d’un cas lui-même.

Déclaration de commutation classique :

String result = "";
        switch (day) {
            case "M":
            case "W":
            case "F": {
                result = "MWF";
                break;
            }
            case "T":
            case "TH":
            case "S": {
                result = "TTS";
                break;
            }
        };

        System.out.println("Old Switch Result:");
        System.out.println(result);

Avec la nouvelle expression de commutation, nous n’avons pas besoin de mettre break partout, ce qui permet d’éviter les erreurs de logique !

String result = switch (day) {
            case "M", "W", "F" -> "MWF";
            case "T", "TH", "S" -> "TTS";
            default -> {
                if(day.isEmpty())
                    break "Please insert a valid day.";
                else
                    break "Looks like a Sunday.";
            }

        };

        System.out.println(result);

Exécutons le programme ci-dessous contenant la nouvelle expression de commutation en utilisant JDK 12.

public class SwitchExpressions {

    public static void main(String[] args)
    {
        System.out.println("New Switch Expression result:");
        executeNewSwitchExpression("M");
        executeNewSwitchExpression("TH");
        executeNewSwitchExpression("");
        executeNewSwitchExpression("SUN");
    }

    public static void executeNewSwitchExpression(String day){

        String result = switch (day) {
            case "M", "W", "F" -> "MWF";
            case "T", "TH", "S" -> "TTS";
            default -> {
                if(day.isEmpty())
                    break "Please insert a valid day.";
                else
                    break "Looks like a Sunday.";
            }

        };

        System.out.println(result);
    }
}

Puisqu’il s’agit d’une fonctionnalité de prévisualisation, veuillez vous assurer d’avoir sélectionné le niveau de langue en tant que Java 12 en prévisualisation. Pour compiler le code ci-dessus, exécutez la commande suivante :

javac -Xlint:preview --enable-preview -source 12 src/main/java/SwitchExpressions.java

Après avoir exécuté le programme compilé, nous obtenons ce qui suit dans la console

Les expressions de commutation sont une fonctionnalité de langage de prévisualisation. Cela signifie que même si elle est complète, elle peut ne pas être confirmée dans la future version de Java.

2. Méthode File.mismatch

Java 12 a ajouté la méthode suivante pour comparer deux fichiers :

public static long mismatch(Path path, Path path2) throws IOException

Cette méthode renvoie la position du premier désaccord ou -1L s’il n’y a pas de désaccord. Deux fichiers peuvent présenter un désaccord dans les scénarios suivants :

• Si les octets ne sont pas identiques. Dans ce cas, la position du premier octet discordant est renvoyée.
• Les tailles de fichier ne sont pas identiques. Dans ce cas, la taille du fichier le plus petit est renvoyée.

Un extrait de code d’exemple de IntelliJ Idea est donné ci-dessous :

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;

public class FileMismatchExample {

    public static void main(String[] args) throws IOException {
        Path filePath1 = Files.createTempFile("file1", ".txt");
        Path filePath2 = Files.createTempFile("file2", ".txt");
        Files.writeString(filePath1,"JournalDev Test String");
        Files.writeString(filePath2,"JournalDev Test String");

        long mismatch = Files.mismatch(filePath1, filePath2);

        System.out.println("File Mismatch position... It returns -1 if there is no mismatch");

        System.out.println("Mismatch position in file1 and file2 is >>>>");
        System.out.println(mismatch);

        filePath1.toFile().deleteOnExit();
        filePath2.toFile().deleteOnExit();

        System.out.println();

        Path filePath3 = Files.createTempFile("file3", ".txt");
        Path filePath4 = Files.createTempFile("file4", ".txt");
        Files.writeString(filePath3,"JournalDev Test String");
        Files.writeString(filePath4,"JournalDev.com Test String");

        long mismatch2 = Files.mismatch(filePath3, filePath4);

        System.out.println("Mismatch position in file3 and file4 is >>>>");
        System.out.println(mismatch2);

        filePath3.toFile().deleteOnExit();
        filePath4.toFile().deleteOnExit();



    }

}

La sortie lorsque le programme Java ci-dessus est compilé et exécuté est :

3. Formatage compact des nombres

import java.text.NumberFormat;
import java.util.Locale;

public class CompactNumberFormatting {


    public static void main(String[] args)
    {
        System.out.println("Compact Formatting is:");
        NumberFormat upvotes = NumberFormat
                .getCompactNumberInstance(new Locale("en", "US"), NumberFormat.Style.SHORT);
        upvotes.setMaximumFractionDigits(1);

        System.out.println(upvotes.format(2592) + " upvotes");


        NumberFormat upvotes2 = NumberFormat
                .getCompactNumberInstance(new Locale("en", "US"), NumberFormat.Style.LONG);
        upvotes2.setMaximumFractionDigits(2);
        System.out.println(upvotes2.format(2011) + " upvotes");
    }


}

4. Collecteurs de té

Le collecteur de té est le nouvel utilitaire de collecte introduit dans l’API Streams. Ce collecteur a trois arguments – Deux collecteurs et une bi-fonction. Toutes les valeurs d’entrée sont transmises à chaque collecteur et le résultat est disponible dans la bi-fonction.

double mean = Stream.of(1, 2, 3, 4, 5)
                .collect(Collectors.teeing(
                        summingDouble(i -> i),
                        counting(),
                        (sum, n) -> sum / n));

System.out.println(mean);

La sortie est 3.0.

5. Nouvelles méthodes de chaînes Java

4 nouvelles méthodes ont été introduites en Java 12, qui sont :

• indent(int n)
• transform(Function f)
• Optional describeConstable()
• String resolveConstantDesc​(MethodHandles.Lookup lookup)

Pour connaître en détail les méthodes ci-dessus et leur mise en œuvre, consultez notre tutoriel Java 12 String Methods.

6. JEP 334 : API des constantes JVM

A new package java.lang.constant is introduced with this JEP. This is not that useful for those developers who don’t use constants pool.

7. JEP 305: Correspondance des motifs pour instanceof (Aperçu)

Une autre fonctionnalité de prévisualisation du langage ! L’ancienne méthode pour effectuer une conversion de type d’un type à un autre est :

if (obj instanceof String) {
    String s = (String) obj;
    // utilisez s dans votre code à partir d'ici
}

La nouvelle méthode est :

if (obj instanceof String s) {
    // vous pouvez utiliser s directement ici
} 

Cela nous épargne certaines conversions de type qui étaient inutiles.

Les littéraux de chaînes brutes sont supprimés à partir de JDK 12.

Cela met fin à cet article sur les fonctionnalités de Java 12.