Java 12 - le novità per gli sviluppatori

In questo articolo vediamo le nuove feature introdotte nel linguaggio con la versione 12 di java. Java 12 fa parte del nuovo ciclo di release che vede ogni 6 mesi il rilascio di una nuova versione del linguaggio. Questa versione non ha il supporto lungo (LTS) come la precedente

Ma vediamo adesso le novità per gli sviluppatori:

Indice

1. Switch Expressions (Preview)

Java 12 ha migliorato l’istruzione Switch introducendola nella JEP 325 come preview language feature il che vuol dire che anche se l’implementazione è completa potrebbe non essere confermata nelle prossime versioni del linguaggio.

Il nuovo costrutto può essere utilizzato sia come istruzione che come espressione, quindi potendone assegnare il risultato ad una variabile. La nuova sintassi prevede l’uso della freccia L ->.

Di seguito le novità introdotte nella nuova Switch:

La nuova sintassi rimuove la necessita di usare l’istruzione break in ogni opzione.
E’ possibile definire piu’ costanti nella stessa etichetta.
il caso di default è adesso obbligatorio .
break può essere usato per restituire valori dalla Switch Expression.

Esempi

Switch classica:

String animale = "";
        switch (razza) {
            case "Persiano":
            case "Siamese":
            case "Soriano": {
                animale = "Gatto";
                break;
            }
            case "Pastore Tedesco":
            case "Yorkshire":
            case "Bracco": {
                animale = "Cane";
                break;
            }
        };

        System.out.println("Risultato vecchia switch:");
        System.out.println(animale);

Nuova Switch:

String animale = switch (razza) {
            case "Persiano", "Siamese", "Soriano" -> "Gatto";
            case "Pastore Tedesco", "Yorkshire", "Bracco" -> "Cane";
            default -> {
                if(razza.isEmpty())
                    break "Inserisci una razza";
                else
                    break "Razza Sconosciuta";
            }

        };
        System.out.println(animale);

2. File.mismatch method

Java 12 introduce un nuovo metodo per confrontare due file. La firma del metodo è la seguente:

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

Questo metodo restituisce la posizione della prima differenza oppure -1L se non i due file risultano uguali.

Due file possono presentare una differenza nei seguenti scenari:

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

3. Compact Number Formatting

E’ stato introdotto il supporto alla notazione compatta alla classe NumberFormat che permette di formattare un numero in varie notazioni compatte in base al Locale impostato. Ma vediamo un esempio per capire meglio le cose:

public class CompactNumberFormatDemo
{
  private static void esempiCompactNumberFormatting(final long numberToFormat){
 final NumberFormat nfDefault = NumberFormat.getCompactNumberInstance();
 final NumberFormat nfItShort =  NumberFormat.getCompactNumberInstance(Locale.ITALY, NumberFormat.Style.SHORT);
 final NumberFormat nfItLong = NumberFormat.getCompactNumberInstance(Locale.ITALY, NumberFormat.Style.LONG);
 final NumberFormat nfFrShort = NumberFormat.getCompactNumberInstance(Locale.FRANCE, NumberFormat.Style.SHORT);
 final NumberFormat nfFrLong = NumberFormat.getCompactNumberInstance(Locale.FRANCE, NumberFormat.Style.LONG);


out.println("Numero da formattare '" + numberToFormat + "':");
out.println("\tDefault:  " + nfDefault.format(numberToFormat));
out.println("\tIT/Short: " + nfItShort.format(numberToFormat));
out.println("\tIT/Long: " + nfItLong.format(numberToFormat));
out.println("\tFR/Short: " + nfFrShort.format(numberToFormat));
out.println("\tFR/Long:  " + nfFrLong.format(numberToFormat));

}

 public static void main(final String[] arguments)
 {
      esempiCompactNumberFormatting(15000);
 }

}

L’output è il seguente:

Numero da formattare '15000':
Default:  15K
IT/Short: 15.000
IT/Long:  15 mila
FR/Short: 15 k
FR/Long:  15 mille

4. Teeing Collectors

Teeing Collector è la nuova collector utility introdotta nella Streams API. Esiste un nuovo metodo statico Collectors::teeing che similmente al comando Linux tee redireziona l’input ai due collettori prima di fare il merge dei loro risultati mediante una Bi-function. Vediamo un esempio in cui splittiamo uno stream di nomi in due liste in base a dei filtri:

var result = Stream.of("Marco", "Maria", "Luigi", "Lucia",
"Francesco").collect(Collectors.teeing(
// primo collector
Collectors.filtering(n -> n.contains("ar"), Collectors.toList()),
// secondo collector
Collectors.filtering(n -> n.endsWith("ia"), Collectors.toList()),
// merger Bi-function
(List<String> list1, List<String> list2) -> List.of(list1, list2)
));
System.out.println(result); // -> [[Marco, Maria], [Maria, Lucia]]

5. Nuovi metodi della classe String

Con java 12 sono stati introdotti 4 nuovi metodi nella classe String

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

Riferirsi alla documentazione ufficiale per i dettagli su questi nuovi metodi.

6. JVM Constants API

Con la JEP 334 è stato introdotto un nuovo package java.lang.constant che contiene i descrittori nominali di vari tipi di costanti. Questi descrittori nominali sono utili per le applicazioni che manipolano i file di classe e i tool di analisi dei programmi nelle fasi di compilazione o di linking.

7. JEP 305: Pattern Matching for instanceof (Preview)

Anche questa è una feature in preview e riguarda l’operatore instanceof che ci permette di testare a quale classe appartiene un determinato oggetto. In questa nuova implementazione non è piu’ necessario fare il casting esplicito di in oggetto per poterlo utilizare. Esempio:

// Prima di java 12
if (obj instanceof String) {
    String s = (String) obj;
    // usa s come stringa
}

// In java 12 e forse anche dopo...
if (obj instanceof String s) {
  // è possibile usare s come stringa direttamente senza bisogno del casting
}

In Java 12 sono state rimosse le Raw String Literals

E’ questo è tutto sulle novità per gli sviluppatori in Java 12.

Java 12 – le novità per gli sviluppatori