Características de Java 13

Tutoriales
Java

Java 13 fue lanzado para uso en producción el 17 de septiembre de 2019. No hay muchas características específicas para desarrolladores en Java 13 debido al ciclo de lanzamiento de 6 meses.

Características de Java 13

Algunas de las características importantes de Java 13 son:

  • Bloques de texto – JEP 355
  • Nuevos métodos en la clase String para bloques de texto
  • Mejoras en las expresiones switch – JEP 354
  • Reimplementación de la API de Socket heredada – JEP 353
  • Archivo CDS dinámico – JEP 350
  • ZGC: Liberar memoria no utilizada – JEP 351
  • Método FileSystems.newFileSystem()
  • Soporte para Unicode 12.1
  • Factories DOM y SAX con soporte de espacio de nombres

Cómo habilitar las características de vista previa

Las expresiones switch y los bloques de texto son características de vista previa. Por lo tanto, deberás habilitar la configuración de funciones de vista previa en tu proyecto. Si ejecutas un programa Java desde la línea de comandos, puedes habilitarlo utilizando el interruptor --enable-preview. Puedes usar este interruptor para iniciar JShell con las funciones de vista previa habilitadas.

$ jshell --enable-preview

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

Si estás utilizando el entorno de desarrollo Eclipse, puedes habilitar las funciones de vista previa desde la configuración del compilador Java del proyecto.

Eclipse Enable Preview Features

1. Bloques de Texto – JEP 355

Esta es una función de vista previa. Nos permite crear cadenas de múltiples líneas fácilmente. La cadena de múltiples líneas debe escribirse dentro de un par de comillas triples dobles. El objeto de cadena creado usando bloques de texto no tiene propiedades adicionales. Es una forma más fácil de crear cadenas de múltiples líneas. No podemos usar bloques de texto para crear una cadena de una sola línea. Las comillas triples dobles de apertura deben seguirse de un terminador de línea.

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

}

Salida:

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

Es útil para crear fácilmente cadenas HTML y JSON en nuestro programa 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. Nuevos Métodos en la Clase String para Bloques de Texto

Hay tres nuevos métodos en la clase String, asociados con la función de bloques de texto.

  1. formatted(Object… args): es similar al método format() de String. Se agrega para admitir el formato con bloques de texto.
  2. stripIndent(): se utiliza para eliminar los caracteres de espacio en blanco incidentales del principio y final de cada línea en el bloque de texto. Este método es utilizado por los bloques de texto y preserva la indentación relativa del contenido.
  3. translateEscapes(): devuelve una cadena cuyo valor es esta cadena, con secuencias de escape traducidas como si estuvieran en un literal de cadena.
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());
		
	}

}

Salida:

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. Mejoras en las Expresiones de Switch – JEP 354

Las expresiones de switch se agregaron como una característica preliminar en la versión Java 12. Es casi igual en Java 13, excepto que el “break” ha sido reemplazado por “yield” para devolver un valor desde la instrucción case.

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

		// desde Java 13 en adelante - instrucciones case de múltiples etiquetas
		switch (choice) {
		case 1, 2, 3:
			System.out.println(choice);
			break;
		default:
			System.out.println("integer is greater than 3");
		}

		// expresiones de switch, usa yield para devolver, en 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. Reimplementar la API de Socket Heredada – JEP 353

La implementación subyacente de las API java.net.Socket y java.net.ServerSocket ha sido reescrita. La nueva implementación, NioSocketImpl, es un reemplazo directo de PlainSocketImpl. Utiliza bloqueos java.util.concurrent en lugar de métodos sincronizados. Si desea utilizar la implementación heredada, use la opción de Java -Djdk.net.usePlainSocketImpl.

5. Archivo CDS Dinámico – JEP 350

Este JEP extiende la característica de compartir datos de clase, que se introdujo en Java 10. Ahora, la creación de archivos CDS y su uso es mucho más fácil.

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

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

6. ZGC: Descompromiso de Memoria No Utilizada – JEP 351

Este JEP ha mejorado ZGC para devolver la memoria del montón no utilizada al sistema operativo. El Recolector de Basura Z fue introducido en Java 11. Agrega un breve tiempo de pausa antes de la limpieza de la memoria del montón. Pero, la memoria no utilizada no estaba siendo devuelta al sistema operativo. Esto era una preocupación para dispositivos con un pequeño tamaño de memoria como IoT y microchips. Ahora, se ha mejorado para devolver la memoria no utilizada al sistema operativo.

7. Método FileSystems.newFileSystem()

Tres nuevos métodos se han añadido a la clase FileSystems para facilitar el uso de proveedores de sistemas de archivos, los cuales tratan el contenido de un archivo como un sistema de archivos.

  1. newFileSystem(Path)
  2. newFileSystem(Path, Map<String, ?>)
  3. newFileSystem(Path, Map<String, ?>, ClassLoader)

8. Fábricas DOM y SAX con Soporte de Espacios de Nombres

Existen nuevos métodos para instanciar fábricas DOM y SAX con soporte de espacios de nombres.

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

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

Conclusión

Parece que la versión de Java lanzada cada 6 meses ha estado funcionando bien. No hay muchas características específicas para los desarrolladores, pero en general es una gran versión. Es bueno ver el tan esperado soporte de bloques de texto.

Referencias

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