Caratteristiche di Java 12

Finalmente, JDK 12 che fa parte del ciclo di rilascio semestrale, è qui. Viene dopo l’ultima versione LTS di Java 11. Abbiamo discusso a lungo delle funzionalità di Java 11 prima. Oggi parleremo delle funzionalità di Java 12 e vedremo cosa ha in serbo per gli sviluppatori. Java 12 è stato lanciato il 19 marzo 2019. È una versione non LTS. Pertanto, non avrà supporto a lungo termine.

Funzionalità di Java 12

Alcune delle importanti funzionalità di Java 12 sono;

1. Cambiamenti del JVM – JEP 189, JEP 346, JEP 344 e JEP 230.
2. Espressioni di switch
3. Metodo mismatch() dei file
4. Formattazione compatta dei numeri
5. Collezionisti di tipo Teeing nell’API Stream
6. Nuovi metodi di Java Strings – indent(), transform(), describeConstable() e resolveConstantDesc().
7. JEP 334: API delle costanti del JVM
8. JEP 305: Corrispondenza di modelli per instanceof
9. Le lettere stringa non elaborate sono state rimosse da JDK 12.

Esaminiamo tutte queste funzionalità di Java 12 una per una.

Cambiamenti del JVM

1. JEP 189 – Shenandoah: Un raccoglitore di rifiuti a bassa latenza (Sperimentale)

RedHat ha avviato lo sviluppo del Raccoglitore di Rifiuti Shenandoah per ridurre i tempi di pausa della Garbage Collection. L’idea è eseguire la GC in modo concorrente con i thread Java in esecuzione. Si propone di garantire pause brevi, coerenti e prevedibili, indipendentemente dalla dimensione dell’heap. Quindi non importa se la dimensione dell’heap è di 15 MB o 15 GB. Si tratta di una funzionalità sperimentale in Java 12.

2. JEP 346 – Restituzione rapida della memoria impegnata non utilizzata da G1

A partire da Java 12, G1 verificherà la memoria dell’heap Java durante l’inattività dell’applicazione e la restituirà al sistema operativo. Si tratta di una misura preventiva per conservare e utilizzare la memoria libera.

3. JEP 344: Collezioni Miste Abortibili per G1

Miglioramenti nell’efficienza di G1 includono rendere le raccolte miste di G1 abortibili se potrebbero superare l’obiettivo di pausa definito. Ciò viene fatto suddividendo l’insieme di raccolta mista in obbligatorio e opzionale. In questo modo, il raccoglitore G1 può dare la priorità alla raccolta dell’insieme obbligatorio per raggiungere l’obiettivo di tempo di pausa.

4. JEP 230 e 344

Suite Microbenchmark, JEP 230 aggiunge una suite di microbenchmark di base al codice sorgente JDK. Questo facilita agli sviluppatori l’esecuzione di microbenchmark esistenti e la creazione di nuovi. One AArch64 Port, Not Two, JEP 344, rimuove tutte le sorgenti relative alla porta arm64 mantenendo la porta ARM a 32 bit e la porta aarch64 a 64 bit. Ciò consente ai contributori di concentrare i loro sforzi su una singola implementazione ARM a 64 bit

5. JEP 341 Archivi CDS predefiniti

Questo migliora il processo di compilazione JDK per generare un archivio di condivisione dei dati di classe (CDS), utilizzando l’elenco di classi predefinito, su piattaforme a 64 bit. L’obiettivo è migliorare il tempo di avvio. Da Java 12, CDS è attivo per impostazione predefinita. Per eseguire il programma con CDS disattivato, eseguire il seguente comando:

java -Xshare:off HelloWorld.java

Ora, ciò comporterebbe un ritardo nel tempo di avvio del programma.

Cambiamenti e Funzionalità del Linguaggio

Java 12 ha introdotto molte funzionalità del linguaggio. Vediamo alcune con le relative implementazioni.

1. Espressioni Switch (Anteprima)

Java 12 ha potenziato le espressioni Switch per il Pattern matching. Introdotto in JEP 325, come una caratteristica del linguaggio in anteprima, la nuova sintassi è L ->. Ecco alcune cose da notare sulle Espressioni Switch:

• La nuova sintassi elimina la necessità dell’istruzione break per evitare i passaggi successivi.
• Le Espressioni Switch non passano più attraverso.
• Inoltre, possiamo definire più costanti nello stesso label.
• Il caso default è ora obbligatorio nelle Espressioni Switch.
• break è usato nelle Espressioni Switch per restituire valori dal caso stesso.

Istruzione switch classica:

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);

Con la nuova Espressione Switch, non dobbiamo impostare break ovunque, evitando così errori logici!

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);

Eseguiamo il programma sottostante contenente la nuova Espressione Switch usando 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);
    }
}

Poiché questa è una funzionalità anteprima, assicurati di aver selezionato il Livello di Linguaggio come Java 12 anteprima. Per compilare il codice sopra, esegui il seguente comando:

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

Dopo aver eseguito il programma compilato, otteniamo il seguente risultato nella console

Le espressioni switch sono una funzionalità del linguaggio in anteprima. Ciò significa che anche se è completa, potrebbe non essere confermata nelle future versioni di Java.

2. Metodo File.mismatch

Java 12 ha aggiunto il seguente metodo per confrontare due file:

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

Questo metodo restituisce la posizione del primo mismatch o -1L se non c’è alcun mismatch. Due file possono avere un mismatch nei seguenti scenari:

• Se i byte non sono identici. In questo caso, viene restituita la posizione del primo byte di mismatch.
• Le dimensioni dei file non sono identiche. In questo caso, viene restituita la dimensione del file più piccolo.

Di seguito è riportato un esempio di snippet di codice da IntelliJ Idea:

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();



    }

}

L’output quando il precedente programma Java viene compilato ed eseguito è:

3. Formattazione compatta dei numeri

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. Collettori di biforcazione

Il Collettore di biforcazione è la nuova utility di raccolta introdotta nell’API di Streams. Questo collettore ha tre argomenti – Due collettori e una Bi-funzione. Tutti i valori di input vengono passati a ciascun collettore e il risultato è disponibile nella Bi-funzione.

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

System.out.println(mean);

Il risultato è 3.0.

5. Nuovi Metodi delle Stringhe in Java

Sono stati introdotti 4 nuovi metodi in Java 12 che sono:

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

Per conoscere dettagliatamente i metodi sopra elencati e la loro implementazione, fare riferimento al nostro tutorial Metodi delle Stringhe in Java 12.

6. JEP 334: API Costanti 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: Pattern Matching per instanceof (Anteprima)

Un’altra anteprima delle funzionalità del linguaggio! Il vecchio modo di fare il cast di un tipo a un altro tipo è:

if (obj instanceof String) {
    String s = (String) obj;
    // usa s nel tuo codice da qui
}

Il nuovo modo è:

if (obj instanceof String s) {
    // puoi usare s direttamente qui
} 

Questo ci risparmia alcuni casting di tipo che erano superflui.

Le Stringhe Grezze (Raw String Literals) sono state rimosse da JDK 12.

Questo conclude l’articolo sulle caratteristiche di Java 12.