Recursos do Java 12

Finalmente, o JDK 12, que faz parte do ciclo de lançamento de seis meses, está aqui. Ele vem após a última versão LTS do Java 11. Nós discutimos extensivamente sobre os recursos do Java 11 anteriormente. Hoje estaremos discutindo os recursos do Java 12 e veremos o que ele reserva para os desenvolvedores. O Java 12 foi lançado em 19 de março de 2019. É uma versão Non-LTS. Portanto, não terá suporte a longo prazo.

Recursos do Java 12

Alguns dos recursos importantes do Java 12 são;

1. Alterações no JVM – JEP 189, JEP 346, JEP 344 e JEP 230.
2. Expressões Switch
3. Método mismatch() de Arquivo
4. Formatação Compacta de Números
5. Collectors Teing na API de Fluxo
6. Novos Métodos de Strings do Java – indent(), transform(), describeConstable() e resolveConstantDesc().
7. JEP 334: API de Constantes do JVM
8. JEP 305: Correspondência de Padrões para instanceof
9. Raw String Literals são Removidos do JDK 12.

Vamos analisar todos esses recursos do Java 12 um por um.

Alterações no JVM

1. JEP 189 – Shenandoah: Um Coletor de Lixo de Baixo Tempo de Pausa (Experimental)

A RedHat iniciou o Coletor de Lixo Shenandoah para reduzir os tempos de pausa do GC. A ideia é executar o GC simultaneamente com as threads Java em execução. Ele visa pausas curtas consistentes e previsíveis, independentemente do tamanho do heap. Portanto, não importa se o tamanho do heap é de 15 MB ou 15 GB. É uma funcionalidade experimental no Java 12.

2. JEP 346 – Retornar Rapidamente Memória Comitada Não Utilizada do G1

A partir do Java 12, o G1 agora verificará a memória do heap Java durante a inatividade da aplicação e a devolverá ao sistema operacional. Esta é uma medida preventiva para conservar e utilizar a memória livre.

3. JEP 344: Coleções Mistas Abortáveis para G1

As melhorias na eficiência do G1 incluem tornar as coletas mistas do G1 interrompíveis se puderem exceder a meta de pausa definida. Isso é feito dividindo o conjunto de coleta mista em obrigatório e opcional. Assim, o coletor G1 pode priorizar a coleta do conjunto obrigatório primeiro para atender à meta de tempo de pausa.

4. JEP 230 e 344

Suite de Microbenchmark, JEP 230 adiciona uma suíte básica de microbenchmarks ao código-fonte do JDK. Isso facilita para os desenvolvedores executar microbenchmarks existentes e criar novos. One AArch64 Port, Not Two, JEP 344, remove todas as fontes relacionadas à porta arm64, mantendo a porta ARM de 32 bits e a porta aarch64 de 64 bits. Isso permite que os colaboradores concentrem seus esforços em uma única implementação de 64 bits para ARM

5. JEP 341 Arquivos CDS Padrão

Isso aprimora o processo de compilação do JDK para gerar um arquivo de compartilhamento de dados de classe (CDS), usando a lista de classes padrão, em plataformas de 64 bits. O objetivo é melhorar o tempo de inicialização. A partir do Java 12, o CDS está ativado por padrão. Para executar seu programa com o CDS desativado, faça o seguinte:

java -Xshare:off HelloWorld.java

Agora, isso poderia atrasar o tempo de inicialização do programa.

Alterações e Recursos de Linguagem

O Java 12 introduziu muitos recursos de linguagem. Vamos dar uma olhada em alguns com implementações.

1. Expressões Switch (Prévia)

O Java 12 aprimorou as expressões Switch para correspondência de padrões. Introduzido no JEP 325, como um recurso de linguagem de prévia, a nova Sintaxe é L ->. Seguem algumas coisas a serem observadas sobre as Expressões Switch:

• A nova Sintaxe elimina a necessidade da instrução break para evitar quedas de execução.
• As Expressões Switch não têm mais queda de execução.
• Além disso, podemos definir múltiplas constantes no mesmo rótulo.
• O caso default agora é obrigatório nas Expressões Switch.
• O break é usado nas Expressões Switch para retornar valores de um caso em si.

Declaração switch clássica:

String result = "";
        switch (day) {
            case "M":
            case "W":
            case "F": {
                result = "MWF";
                break;
            }
            case "T":
            case "TH":
            case "S": {
                result = "TTS";
                break;
            }
        };

        System.out.println("Old Switch Result:");
        System.out.println(result);

Com a nova Expressão Switch, não precisamos definir o break em todos os lugares, evitando assim erros lógicos!

String result = switch (day) {
            case "M", "W", "F" -> "MWF";
            case "T", "TH", "S" -> "TTS";
            default -> {
                if(day.isEmpty())
                    break "Please insert a valid day.";
                else
                    break "Looks like a Sunday.";
            }

        };

        System.out.println(result);

Vamos executar o programa abaixo contendo a nova Expressão Switch usando o JDK 12.

public class SwitchExpressions {

    public static void main(String[] args)
    {
        System.out.println("New Switch Expression result:");
        executeNewSwitchExpression("M");
        executeNewSwitchExpression("TH");
        executeNewSwitchExpression("");
        executeNewSwitchExpression("SUN");
    }

    public static void executeNewSwitchExpression(String day){

        String result = switch (day) {
            case "M", "W", "F" -> "MWF";
            case "T", "TH", "S" -> "TTS";
            default -> {
                if(day.isEmpty())
                    break "Please insert a valid day.";
                else
                    break "Looks like a Sunday.";
            }

        };

        System.out.println(result);
    }
}

Uma vez que esta é uma funcionalidade de visualização, certifique-se de ter selecionado o Nível de Linguagem como Java 12 visualização. Para compilar o código acima, execute o seguinte comando:

javac -Xlint:preview --enable-preview -source 12 src/main/java/SwitchExpressions.java

Depois de executar o programa compilado, obtemos o seguinte no console

As expressões de switch são uma característica de visualização da linguagem. Isso significa que, mesmo que esteja completa, pode não ser confirmada em futuras versões do Java.

2. Método de desajuste de arquivo

O Java 12 adicionou o seguinte método para comparar dois arquivos:

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

Este método retorna a posição do primeiro desajuste ou -1L se não houver desajuste. Dois arquivos podem ter um desajuste nos seguintes cenários:

• Se os bytes não forem idênticos. Nesse caso, é retornada a posição do primeiro byte que não coincide.
• Os tamanhos dos arquivos não são idênticos. Nesse caso, é retornado o tamanho do arquivo menor.

Um trecho de código de exemplo do IntelliJ Idea é fornecido abaixo:

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;

public class FileMismatchExample {

    public static void main(String[] args) throws IOException {
        Path filePath1 = Files.createTempFile("file1", ".txt");
        Path filePath2 = Files.createTempFile("file2", ".txt");
        Files.writeString(filePath1,"JournalDev Test String");
        Files.writeString(filePath2,"JournalDev Test String");

        long mismatch = Files.mismatch(filePath1, filePath2);

        System.out.println("File Mismatch position... It returns -1 if there is no mismatch");

        System.out.println("Mismatch position in file1 and file2 is >>>>");
        System.out.println(mismatch);

        filePath1.toFile().deleteOnExit();
        filePath2.toFile().deleteOnExit();

        System.out.println();

        Path filePath3 = Files.createTempFile("file3", ".txt");
        Path filePath4 = Files.createTempFile("file4", ".txt");
        Files.writeString(filePath3,"JournalDev Test String");
        Files.writeString(filePath4,"JournalDev.com Test String");

        long mismatch2 = Files.mismatch(filePath3, filePath4);

        System.out.println("Mismatch position in file3 and file4 is >>>>");
        System.out.println(mismatch2);

        filePath3.toFile().deleteOnExit();
        filePath4.toFile().deleteOnExit();



    }

}

A saída quando o programa Java acima é compilado e executado é:

3. Formatação de número compacta

import java.text.NumberFormat;
import java.util.Locale;

public class CompactNumberFormatting {


    public static void main(String[] args)
    {
        System.out.println("Compact Formatting is:");
        NumberFormat upvotes = NumberFormat
                .getCompactNumberInstance(new Locale("en", "US"), NumberFormat.Style.SHORT);
        upvotes.setMaximumFractionDigits(1);

        System.out.println(upvotes.format(2592) + " upvotes");


        NumberFormat upvotes2 = NumberFormat
                .getCompactNumberInstance(new Locale("en", "US"), NumberFormat.Style.LONG);
        upvotes2.setMaximumFractionDigits(2);
        System.out.println(upvotes2.format(2011) + " upvotes");
    }


}

4. Coletores de Teeing

O Coletor de Teeing é a nova utilidade de coleta introduzida na API de Streams. Este coletor possui três argumentos – Dois coletores e uma Bi-função. Todos os valores de entrada são passados para cada coletor e o resultado está disponível na Bi-função.

double mean = Stream.of(1, 2, 3, 4, 5)
                .collect(Collectors.teeing(
                        summingDouble(i -> i),
                        counting(),
                        (sum, n) -> sum / n));

System.out.println(mean);

A saída é 3.0.

5. Novos Métodos de Strings em Java

Foram introduzidos 4 novos métodos no Java 12, que são:

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

Para saber mais sobre os métodos acima e sua implementação detalhada, consulte nosso tutorial Métodos de String em Java 12.

6. JEP 334: API de Constantes da JVM

A new package java.lang.constant is introduced with this JEP. This is not that useful for those developers who don’t use constants pool.

7. JEP 305: Correspondência de Padrões para instanceof (Visualização)

Outro recurso de visualização de idioma! A maneira antiga de fazer o typecast de um tipo para outro tipo é:

if (obj instanceof String) {
    String s = (String) obj;
    // use s in your code from here
}

A nova maneira é:

if (obj instanceof String s) {
    // pode usar s diretamente aqui
} 

Isso nos poupa alguns typecasting que eram desnecessários.

As Literais de String Brutas foram Removidas do JDK 12.

Isso encerra este artigo sobre os recursos do Java 12.