Caratteristiche di Java 13

Tutorial
Java

Java 13 è stato rilasciato per l’uso in produzione il 17 settembre 2019. Non ci sono molte funzionalità specifiche per gli sviluppatori in Java 13 a causa del ciclo di rilascio semestrale.

Funzionalità di Java 13

Alcune delle importanti caratteristiche di Java 13 sono:

  • Text Blocks – JEP 355
  • Nuovi metodi nella classe String per i blocchi di testo
  • Miglioramenti nelle espressioni switch – JEP 354
  • Rimplementazione dell’API Socket legacy – JEP 353
  • Archivio dinamico CDS – JEP 350
  • ZGC: Libera la memoria non utilizzata – JEP 351
  • Metodo FileSystems.newFileSystem()
  • Supporto per Unicode 12.1
  • DOM e SAX Factories con supporto per lo spazio dei nomi

Come abilitare le funzionalità di anteprima

Le espressioni switch e i blocchi di testo sono funzionalità di anteprima. Quindi dovrai abilitare le impostazioni delle funzionalità di anteprima nel tuo progetto. Se stai eseguendo un programma Java dalla riga di comando, puoi abilitarlo utilizzando l’interruttore --enable-preview. Puoi utilizzare questo interruttore per avviare JShell con le funzionalità di anteprima abilitate.

$ jshell --enable-preview

$ java --enable-preview --source 13 Test.java

Se stai utilizzando l’IDE Eclipse, puoi abilitare le funzionalità di anteprima dalle impostazioni del compilatore Java del progetto.

Eclipse Enable Preview Features

1. Blocchi di Testo – JEP 355

Questa è una funzionalità di anteprima. Ci consente di creare facilmente stringhe multilinea. La stringa multilinea deve essere scritta all’interno di un paio di triple virgolette doppie. L’oggetto stringa creato usando i blocchi di testo non ha proprietà aggiuntive. È un modo più semplice per creare stringhe multilinea. Non possiamo utilizzare i blocchi di testo per creare una stringa su una sola linea. Le triple virgolette doppie di apertura devono essere seguite da un terminatore di riga.

package com.journaldev.java13.examples;

public class TextBlockString {

	/**
	 * JEP 355: Preview Feature
	 */
	@SuppressWarnings("preview")
	public static void main(String[] args) {
		String textBlock = """
				Hi
				Hello
				Yes""";

		String str = "Hi\nHello\nYes";

		System.out.println("Text Block String:\n" + textBlock);
		System.out.println("Normal String Literal:\n" + str);

		System.out.println("Text Block and String Literal equals() Comparison: " + (textBlock.equals(str)));
		System.out.println("Text Block and String Literal == Comparison: " + (textBlock == str));
	}

}

Output:

Text Block String:
Hi
Hello
Yes
Normal String Literal:
Hi
Hello
Yes
Text Block and String Literal equals() Comparison: true
Text Block and String Literal == Comparison: true

È utile per creare facilmente stringhe HTML e JSON nel nostro programma Java.

String textBlockHTML = """
		<html>
		<head>
			<link href='/css/style.css' rel='stylesheet' />
		</head>
		<body>
                        <h1>Hello World</h1>
                </body>
                </html>""";

String textBlockJSON = """
		{
			"name":"Pankaj",
			"website":"JournalDev"
		}""";

2. Nuovi Metodi nella Classe String per i Blocchi di Testo

Ci sono tre nuovi metodi nella classe String, associati alla funzionalità dei blocchi di testo.

  1. formatted(Object… args): è simile al metodo format() di String. È stato aggiunto per supportare la formattazione con i blocchi di testo.
  2. stripIndent(): utilizzato per rimuovere i caratteri di spazio bianco incidentali dall’inizio alla fine di ogni riga nel blocco di testo. Questo metodo è utilizzato dai blocchi di testo e preserva l’indentazione relativa del contenuto.
  3. translateEscapes(): restituisce una stringa il cui valore è questa stringa, con sequenze di escape tradotte come se fossero in un letterale di stringa.
package com.journaldev.java13.examples;

public class StringNewMethods {

	/***
	 * New methods are to be used with Text Block Strings
	 * @param args
	 */
	@SuppressWarnings("preview")
	public static void main(String[] args) {
		
		String output = """
			    Name: %s
			    Phone: %d
			    Salary: $%.2f
			    """.formatted("Pankaj", 123456789, 2000.5555);
		
		System.out.println(output);
		
		
		String htmlTextBlock = "<html>   \n"+
				                    "\t<body>\t\t \n"+
				                        "\t\t<p>Hello</p>  \t \n"+
				                    "\t</body> \n"+
				                "</html>";
		System.out.println(htmlTextBlock.replace(" ", "*"));
		System.out.println(htmlTextBlock.stripIndent().replace(" ", "*"));
		
		String str1 = "Hi\t\nHello' \" /u0022 Pankaj\r";
		System.out.println(str1);
		System.out.println(str1.translateEscapes());
		
	}

}

Output:

Name: Pankaj
Phone: 123456789
Salary: $2000.56

<html>***
	<body>		*
		<p>Hello</p>**	*
	</body>*
</html>
<html>
	<body>
		<p>Hello</p>
	</body>
</html>
Hi	
Hello' " /u0022 Pankaj
Hi	
Hello' " /u0022 Pankaj

3. Miglioramenti delle espressioni switch – JEP 354

Le espressioni switch sono state aggiunte come funzionalità di anteprima nel rilascio di Java 12. È quasi lo stesso in Java 13 eccetto che il “break” è stato sostituito con “yield” per restituire un valore dalla dichiarazione di caso.

package com.journaldev.java13.examples;

/**
 * JEP 354: Switch Expressions
 * https://openjdk.java.net/jeps/354
 * @author pankaj
 *
 */
public class SwitchEnhancements {

	@SuppressWarnings("preview")
	public static void main(String[] args) {
		int choice = 2;

		switch (choice) {
		case 1:
			System.out.println(choice);
			break;
		case 2:
			System.out.println(choice);
			break;
		case 3:
			System.out.println(choice);
			break;
		default:
			System.out.println("integer is greater than 3");
		}

		// da Java 13 in poi - dichiarazioni di caso multi-etichetta
		switch (choice) {
		case 1, 2, 3:
			System.out.println(choice);
			break;
		default:
			System.out.println("integer is greater than 3");
		}

		// espressioni switch, utilizzare yield per restituire, in Java 12 era break
		int x = switch (choice) {
		case 1, 2, 3:
			yield choice;
		default:
			yield -1;
		};
		System.out.println("x = " + x);

	}

	enum Day {
		SUN, MON, TUE
	};

	@SuppressWarnings("preview")
	public String getDay(Day d) {
		String day = switch (d) {
		case SUN -> "Sunday";
		case MON -> "Monday";
		case TUE -> "Tuesday";
		};
		return day;
	}
}

4. Reimplementare l’API dei socket legacy – JEP 353

L’implementazione sottostante delle API java.net.Socket e java.net.ServerSocket è stata riscritta. La nuova implementazione, NioSocketImpl, è una sostituzione plug-in per PlainSocketImpl. Utilizza i blocchi java.util.concurrent anziché metodi sincronizzati. Se si desidera utilizzare l’implementazione legacy, utilizzare l’opzione java -Djdk.net.usePlainSocketImpl.

5. Archivio CDS Dinamico – JEP 350

Questa JEP estende la funzionalità di condivisione dei dati di classe, introdotta in Java 10. Ora, la creazione dell’archivio CDS e il suo utilizzo sono molto più semplici.

$ java -XX:ArchiveClassesAtExit=my_app_cds.jsa -cp my_app.jar

$ java -XX:SharedArchiveFile=my_app_cds.jsa -cp my_app.jar

6. ZGC: Liberazione Memoria Non Utilizzata – JEP 351

Questa JEP ha potenziato ZGC per restituire la memoria heap non utilizzata al sistema operativo. Il raccoglitore di rifiuti Z è stato introdotto in Java 11. Aggiunge un breve tempo di pausa prima della pulizia della memoria heap. Ma la memoria inutilizzata non veniva restituita al sistema operativo. Questo era un problema per dispositivi con una piccola impronta di memoria, come IoT e microchip. Ora è stato potenziato per restituire la memoria inutilizzata al sistema operativo.

7. Metodo FileSystems.newFileSystem()

Sono stati aggiunti tre nuovi metodi alla classe FileSystems per rendere più facile l’uso dei fornitori di sistema di file, che trattano il contenuto di un file come un sistema di file.

  1. newFileSystem(Path)
  2. newFileSystem(Path, Map)
  3. newFileSystem(Path, Map, ClassLoader)

8. Fabbriche DOM e SAX con supporto Namespace

Vi sono nuovi metodi per istanziare fabbriche DOM e SAX con supporto Namespace.

  1. newDefaultNSInstance()
  2. newNSInstance()
  3. newNSInstance(String factoryClassName, ClassLoader classLoader)
//java 13 in poi
DocumentBuilder db = DocumentBuilderFactory.newDefaultNSInstance().newDocumentBuilder(); 

// prima di java 13
DocumentBuilderFactory dbf = DocumentBuilderFactory.newDefaultInstance(); 
dbf.setNamespaceAware(true); 
DocumentBuilder db = dbf.newDocumentBuilder();

Conclusioni

Sembra che il rilascio semestrale di Java stia funzionando bene. Non ci sono molte caratteristiche specifiche per gli sviluppatori, ma nel complesso è un ottimo rilascio. È bello vedere il tanto atteso supporto per stringhe di blocchi di testo.

Riferimenti

Source:
https://www.digitalocean.com/community/tutorials/java-13-features