Java 23 foi lançado oficialmente! É uma versão não LTS (suporte de longo prazo). Mesmo sendo uma versão de curta duração, o Java 23 vem repleto de melhorias interessantes, correções de bugs e também recursos e opções removidos aos quais você pode precisar prestar atenção.

Vamos mergulhar nas novidades e como elas se baseiam em recursos de versões anteriores, como JDK 21 e JDK 22.

Valores com escopo definido: com base nas visualizações do JDK 22 e do JDK 21

Um dos recursos mais esperados no JDK 23 é Scoped Values (Visualização). Esse recurso, que também foi visualizado no JDK 22 e no JDK 21, simplifica a maneira como os métodos compartilham dados imutáveis ​​entre threads e threads filhos. Nas versões anteriores do Java, o tratamento de dados locais de thread poderia ser complicado e consumir muita memória. Os valores com escopo mudam isso, oferecendo uma alternativa mais eficiente e com menores custos indiretos.

O que há de diferente no JDK 23? O método ScopedValue.callWhere() agora usa uma nova interface funcional, o que torna mais fácil para o compilador inferir se uma exceção verificada pode ser lançada. Isso também levou à remoção do método ScopedValue.getWhere(), simplificando ainda mais a API.

Esta é uma continuação das melhorias que vimos em versões anteriores, e é emocionante ver os valores do escopo evoluindo para se tornarem um recurso permanente.

Simultaneidade estruturada: uma terceira prévia

O modelo de simultaneidade do Java sempre foi poderoso, mas difícil de gerenciar. Digite Structured Concurrency (Preview), que apareceu pela primeira vez no JDK 21 e agora atingiu sua terceira visualização no JDK 23. A ideia aqui é tornar a programação simultânea mais intuitiva agrupando tarefas relacionadas executadas em diferentes threads em um única unidade de trabalho. Isso simplifica o tratamento de erros e melhora a confiabilidade dos processos de cancelamento.

No JDK 23, a simultaneidade estruturada permanece na versão prévia, mas continua a tornar o código de simultaneidade mais fácil de raciocinar e menos sujeito a erros. Se você trabalhou com a visualização no JDK 21 ou JDK 22, apreciará como esse recurso amadureceu. Agora está mais bem equipado para lidar com problemas comuns de simultaneidade, como vazamentos de thread, tornando mais fácil escrever código multithread confiável.

Corpos construtores flexíveis: evoluindo desde o JDK 22

Outra adição bem-vinda é Flexible Constructor Bodies (Visualização). Visualizado pela primeira vez no JDK 22 como “instruções antes de super()”, esse recurso permite que os desenvolvedores escrevam código de inicialização antes de invocar o construtor da superclasse. Essa mudança aparentemente pequena pode tornar a lógica do construtor muito mais clara e evitar a criação desnecessária de objetos quando a validação ou outra lógica de configuração falhar.

No JDK 22, esse recurso foi introduzido para dar aos desenvolvedores mais controle sobre a lógica do construtor, e a segunda visualização no JDK 23 continua a refinar esse recurso. Ao mover a lógica de inicialização à frente da invocação da superclasse, os desenvolvedores podem evitar métodos estáticos auxiliares confusos e construtores intermediários que anteriormente sobrecarregavam as bases de código.

Classes declaradas implicitamente: a terceira vez é um encanto

Para aqueles que ensinam Java ou escrevem scripts rápidos, Classes e métodos de instância declarados implicitamente têm sido uma virada de jogo desde sua introdução no JDK 21. Este recurso permite que iniciantes escrevam programas Java simplificados sem a necessidade de entender recursos de linguagem complexos desde o início.

No JDK 23, esse recurso recebe algumas atualizações adicionais. Agora, as classes declaradas implicitamente podem importar automaticamente três métodos estáticos para E/S de texto simples e também importarão todas as classes e interfaces públicas de nível superior do módulo java.base sob demanda. Essas melhorias ajudam a tornar a curva de aprendizado ainda mais suave para os recém-chegados.

Declarações de importação de módulo: uma nova prévia

Um dos novos recursos de visualização do JDK 23 é Declarações de importação de módulo. Este recurso permite importar todos os pacotes exportados por um módulo com uma única instrução, simplificando a reutilização de bibliotecas modulares. É especialmente útil para iniciantes que não precisam mais memorizar onde os pacotes estão localizados na hierarquia e reduz a confusão causada por múltiplas declarações de importação de tipo sob demanda.

Embora este seja um recurso totalmente novo no JDK 23, ele se mostra uma grande promessa em tornar o sistema de módulos Java mais acessível, especialmente para aqueles que são novos na programação modular.

Comentários da documentação do Markdown: uma nova era para Javadoc

Sejamos honestos: escrever JavaDoc com HTML e as tags @ pode ser doloroso. No JDK 23, o recurso Markdown Documentation Comments (Pré-visualização) permite que os desenvolvedores escrevam documentação de API usando Markdown, facilitando a criação de comentários legíveis e bem formatados.

Embora este seja um novo recurso no JDK 23, é algo que deveria ter sido adicionado anos atrás. Markdown é amplamente utilizado em comunidades de desenvolvedores, e trazê-lo para JavaDoc tornará a escrita e manutenção de documentação muito mais fácil.

Z Garbage Collector (ZGC): modo geracional por padrão

Se você trabalha com o Z Garbage Collector (ZGC) desde sua introdução no JDK 15, ficará animado em saber que no JDK 23, o ZGC agora usa como padrão geracional modo (JEP 474). Essa opção melhora o desempenho do aplicativo, concentrando-se na coleta frequente de objetos de curta duração. Embora o ZGC não geracional esteja obsoleto nesta versão, é um sinal claro de que a abordagem geracional é o futuro da coleta de lixo em Java.

Se você estiver executando o JDK 22 ou anterior, a mudança para o JDK 23 deve trazer melhorias visíveis de desempenho sem muito esforço de sua parte.

API Vector: ainda em incubação, mas mais poderosa

A Vector API, introduzida no JDK 16, permite que os desenvolvedores executem cálculos vetoriais que compilam instruções vetoriais ideais em tempo de execução. A API continua a evoluir e, no JDK 23, estamos vendo a Oitava Incubadora. Esta API ainda está em incubação, o que significa que ainda não é um recurso finalizado, mas está se aproximando da maturidade.

Para aplicativos de desempenho crítico, especialmente aqueles que lidam com grandes conjuntos de dados, a API Vector pode fornecer grandes acelerações. Se você trabalhou com ele em incubações anteriores (como JDK 22), descobrirá que está ainda mais estável agora, mas ainda está esperando que as peças finais se encaixem (provavelmente ligadas ao Projeto Valhalla).

Coletores de fluxo: segunda visualização

JDK 22 introduziu Stream Gatherers (visualização), um recurso que adiciona flexibilidade à API Stream, permitindo operações intermediárias personalizadas. No JDK 23, ele está de volta para uma segunda prévia. Se você adora usar fluxos para processar dados, apreciará a capacidade desse recurso de transformar pipelines de dados de maneiras que antes eram difíceis de alcançar.

Os coletores de stream ampliam o poder dos streams, permitindo que os desenvolvedores lidem com cenários mais complexos com facilidade, principalmente ao trabalhar com streams infinitos ou transformações personalizadas.

API de arquivo de classe: segunda visualização

Se você estiver criando ferramentas que manipulam arquivos de classe Java, a Class-File API (visualização) no JDK 23 é para você. Introduzida pela primeira vez no JDK 22, esta API fornece uma maneira padrão de analisar e gerar arquivos de classe sem a necessidade de bibliotecas de terceiros como ASM. A segunda visualização no JDK 23 refina essa API, tornando-a mais simplificada e fácil de trabalhar.

Para desenvolvedores de ferramentas, isso é um grande negócio. Chega de se esforçar para atualizar bibliotecas sempre que as especificações da JVM mudam – Java agora tem uma solução própria.

Concluindo: você deve atualizar?

Java 23 pode não ser uma versão LTS, mas está repleto de recursos interessantes que se baseiam no que o JDK 21 e o JDK 22 introduziram. Desde valores com escopo definido e simultaneidade estruturada até um coletor de lixo melhor e melhorias em fluxos e construtores, esta versão impulsiona o desenvolvimento Java.