Java 12 – Cosa c'è di nuovo?

Di seguito le nuove feature introdotte nel linguaggio con la versione 12 di java.

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 ->.

Di seguito le novità introdotte nella nuova Switch:

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

Esempio:

// Prima di Java12:
String stagione= "";
switch (mese) {
case "marzo":
case "aprile":
case "maggio": 
{
   stagione= "primavera";
   break;
}
case "giugno":
case "luglio":
case "agosto": 
{
   stagione= "estate";
   break;
}
};

// In Java 12:

String stagione=switch(mese){
     case "marzo", "aprile", "maggio":{
          break "primavera";
     } case "giugno", "luglio", "agosto":{
          break "estate";
     }default ->{
          break "altra stagione";
     }
};

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.

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. Esempio:

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

Otterremo come risultato:

Numero da formattare '15000':

Default: 15K
IT/Short: 15.000
IT/Long: 15 mila
FR/Short: 15 k
FR/Long: 15 mille

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. Esempio:

var result = Stream.of("Andreas", "Antonia", "Lucia",
  "Francesco").collect(Collectors.teeing(
  // primo collector
  Collectors.filtering(n -> n.contains("c"), Collectors.toList()),
  // secondo collector
  Collectors.filtering(n -> n.endsWith("s"), Collectors.toList()),
  // merger Bi-function
  (List
  list1, List
  list2) -> List.of(list1, list2)
));
System.out.println(result); // -> [[Lucia, Francesco], [Andreas]]

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.

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.

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 

-------------------------
L'originale di questo articolo è stato pubblicato su losviluppatore.it

* Obbligatorio

Invia