Recursos do Java 12

Finalmente, o JDK 12, que faz parte do ciclo de lançamentos de seis meses, está aqui. Ele vem após a última versão LTS do Java 11. Nós discutimos detalhadamente sobre as funcionalidades do Java 11 anteriormente. Hoje vamos discutir as funcionalidades do Java 12 e ver 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 de longo prazo.

Funcionalidades do Java 12

Algumas das importantes funcionalidades 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 em 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 é Removido do JDK 12.

Vamos examinar todas essas funcionalidades do Java 12 uma por uma.

Alterações no JVM

1. JEP 189 – Shenandoah: Um Coletor de Lixo de Baixa Latência (Experimental)

A RedHat iniciou o Coletor de Lixo Shenandoah para reduzir os tempos de pausa do GC. A ideia é executar o GC em paralelo 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. É um recurso experimental no Java 12.

2. JEP 346 – Retornar Imediatamente Memória Alocada Não Utilizada pelo 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 Misturadas Abortáveis para o G1

As melhorias na eficiência do G1 incluem tornar as coleções mistas do G1 abortáveis se elas puderem exceder a meta de pausa definida. Isso é feito dividindo o conjunto de coleção mista em obrigatórias e opcionais. 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. Porta AArch64 Única, Não Duas, JEP 344, remove todas as fontes relacionadas à porta arm64, enquanto mantém a porta ARM de 32 bits e a porta aarch64 de 64 bits. Isso permite que os contribuidores concentrem seus esforços em uma única implementação ARM de 64 bits

5. JEP 341 Arquivos CDS Padrão

Isso melhora o processo de construçã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 desligado, faça o seguinte:

java -Xshare:off HelloWorld.java

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

Mudanças e Recursos de Linguagem

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

1. Expressões de Switch (Prévia)

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

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

Declaração de 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 de Switch, não precisamos definir break em todos os lugares, evitando assim erros de lógica!

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

Como esta é uma funcionalidade de visualização, por favor, certifique-se de que selecionou 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

Após executar o programa compilado, obtemos o seguinte no console

As expressões switch são um recurso de linguagem em visualização. Isso significa que, mesmo estando completo, pode não ser confirmado em futuras versões do Java.

2. Método File.mismatch

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 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 corresponde.
• Se os tamanhos dos arquivos não forem idênticos. Nesse caso, é retornado o tamanho do arquivo menor.

Um trecho de código de exemplo do IntelliJ Idea é mostrado 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();



    }

}

O resultado ao compilar e executar o programa Java acima é:

3. Formatação Compacta de Números

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 em Tee

O Coletor em Tee é 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);

O resultado é 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 em detalhes, consulte nosso tutorial sobre Métodos de Strings 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)

Outra característica de visualização da linguagem! O antigo modo de fazer cast de um tipo para outro era:

if (obj instanceof String) {
    String s = (String) obj;
    // use s no seu código a partir daqui
}

O novo modo é:

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

Isso nos poupa alguns casts desnecessários.

Raw String Literals é Removido do JDK 12.

Isso encerra este artigo sobre as características do Java 12.