Recursos do Java 13

Tutoriais
Java

O Java 13 foi lançado para uso em produção em 17 de setembro de 2019. Não há muitos recursos específicos para desenvolvedores no Java 13 devido ao ciclo de lançamento de 6 meses.

Recursos do Java 13

Alguns dos recursos importantes do Java 13 são:

  • Blocos de Texto – JEP 355
  • Novos Métodos na Classe String para Blocos de Texto
  • Aprimoramentos nas Expressões de Switch – JEP 354
  • Reimplementar a API de Socket Legado – JEP 353
  • Arquivo CDS Dinâmico – JEP 350
  • ZGC: Liberar Memória Não Utilizada – JEP 351
  • Método FileSystems.newFileSystem()
  • Suporte para Unicode 12.1
  • Fábricas DOM e SAX com Suporte a Namespace

Como Habilitar Recursos de Visualização

As expressões de switch e blocos de texto são recursos de visualização. Portanto, você precisará habilitar as configurações de visualização em seu projeto. Se estiver executando um programa Java a partir da linha de comando, você pode habilitá-lo usando o --enable-preview switch. Você pode usar este switch para iniciar o JShell com recursos de visualização habilitados.

$ jshell --enable-preview

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

Se estiver usando o Eclipse IDE, você pode habilitar os recursos de visualização nas configurações do compilador Java do projeto.

Eclipse Enable Preview Features

1. Blocos de Texto – JEP 355

Esta é uma funcionalidade de visualização. Permite-nos criar facilmente strings multilinhas. A string multilinha deve ser escrita dentro de um par de aspas triplas duplas. O objeto de string criado usando blocos de texto não possui propriedades adicionais. É uma forma mais fácil de criar strings multilinhas. Não podemos usar blocos de texto para criar uma string de uma única linha. As aspas triplas duplas de abertura devem ser seguidas por um terminador de linha.

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

}

Saída:

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

É útil na criação fácil de strings HTML e JSON em nosso 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. Novos Métodos na Classe String para Blocos de Texto

Há três novos métodos na classe String, associados à funcionalidade de blocos de texto.

  1. formatado (Objeto … args): é semelhante ao método de formato de String. É adicionado para suportar a formatação com os blocos de texto.
  2. stripIndent (): usado para remover os caracteres de espaço em branco incidentais do início e do final de cada linha no bloco de texto. Este método é usado pelos blocos de texto e preserva a indentação relativa do conteúdo.
  3. translateEscapes(): retorna uma string cujo valor é esta string, com sequências de escape traduzidas como se estivessem em um literal de string.
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());
		
	}

}

Saída: 

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. Aperfeiçoamentos em Expressões Switch – JEP 354

As expressões switch foram adicionadas como um recurso de visualização no lançamento do Java 12. É quase o mesmo no Java 13, exceto que o “break” foi substituído por “yield” para retornar um valor da declaração de 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");
		}

		 // a partir do java 13 em diante - declarações de caso multi-rótulo
		switch (choice) {
		case 1, 2, 3:
			System.out.println(choice);
			break;
		default:
			System.out.println("integer is greater than 3");
		}

		 // expressões switch, use yield para retornar, no 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 a API de Socket Legada – JEP 353

A implementação subjacente das APIs java.net.Socket e java.net.ServerSocket foram reescritas. A nova implementação, NioSocketImpl, é uma substituição direta para PlainSocketImpl. Ele usa bloqueios java.util.concurrent em vez de métodos sincronizados. Se você deseja usar a implementação legada, use a opção java -Djdk.net.usePlainSocketImpl.

5. Arquivo CDS Dinâmico – JEP 350

Este JEP estende o recurso de compartilhamento de dados de classe, que foi introduzido no Java 10. Agora, a criação de arquivos CDS e seu uso estão muito mais fáceis.

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

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

6. ZGC: Descomprometimento de Memória Não Utilizada – JEP 351

Este JEP aprimorou o ZGC para devolver a memória de heap não utilizada ao sistema operacional. O Coletor de Lixo Z foi introduzido no Java 11. Ele adiciona um curto tempo de pausa antes da limpeza da memória de heap. Mas, a memória não utilizada não estava sendo devolvida ao sistema operacional. Isso era uma preocupação para dispositivos com uma pegada de memória pequena, como IoT e microchips. Agora, foi aprimorado para devolver a memória não utilizada ao sistema operacional.

7. Método FileSystems.newFileSystem()

Três novos métodos foram adicionados à classe FileSystems para facilitar o uso dos provedores de sistema de arquivos, que tratam o conteúdo de um arquivo como um sistema de arquivos.

  1. newFileSystem(Caminho)
  2. newFileSystem(Caminho, Map<String, ?>)
  3. newFileSystem(Caminho, Map<String, ?>, Carregador de Classe)

8. Fábricas DOM e SAX com Suporte a Namespace

Há novos métodos para instanciar fábricas DOM e SAX com suporte a Namespace.

  1. newDefaultNSInstance()
  2. newNSInstance()
  3. newNSInstance(NomeDaClasseDaFábrica, Carregador de Classe)
//Java 13 em diante
DocumentBuilder db = DocumentBuilderFactory.newDefaultNSInstance().newDocumentBuilder(); 

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

Conclusão

Parece que o lançamento de seis meses do Java tem funcionado bem. Não há muitos recursos específicos para desenvolvedores, mas no geral é um ótimo lançamento. É bom ver o suporte a strings de blocos de texto tão esperado.

Referências

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