Após seis meses de desenvolvimento, a Oracle publicou a plataforma Java SE 23 (Java Platform, Standard Edition 23), que usa o projeto OpenJDK de código aberto como implementação de referência. Com exceção da remoção de alguns recursos obsoletos, o Java SE 23 mantém compatibilidade retroativa com versões anteriores da plataforma Java - a maioria dos projetos Java escritos anteriormente funcionarão sem alterações quando executados na nova versão. Compilações prontas para instalação do Java SE 22 (JDK, JRE e Server JRE) são preparadas para Linux (x86_64, AArch64), Windows (x86_64) e macOS (x86_64, AArch64). Desenvolvida pelo projeto OpenJDK, a implementação de referência Java 23 é totalmente open source sob a licença GPLv2, com exceções GNU ClassPath permitindo vinculação dinâmica com produtos comerciais.
Java SE 23 é classificado como uma versão de suporte regular e continuará recebendo atualizações até a próxima versão. O branch Long Term Support (LTS) deverá ser Java SE 21 ou Java SE 17, que receberá atualizações até 2031 e 2029, respectivamente (disponível geralmente até 2028 e 2026). O suporte estendido para a ramificação LTS do Java SE 8 durará até 2030 e do Java SE 11 até 2032.
Entre as 23 inovações propostas no Java SE:
- O modo generativo de operação do coletor de lixo ZGC (Generation Z Garbage Collector) é habilitado por padrão, usando processamento separado de objetos “antigos” e “jovens”, o que aumenta a eficiência de limpeza de objetos criados recentemente com vida útil curta. O uso do ZGC geracional reduz o risco de paralisações durante a alocação de recursos, reduz a carga da CPU e o consumo de memória durante a coleta de lixo. Testar ZGC geracional com Apache Cassandra 4 mostrou um aumento de 4x na taxa de transferência com um tamanho de heap fixo e uma redução de um quarto no tamanho de heap com taxa de transferência constante.
- JavaDoc adicionou suporte para usar Markdown para documentar código em comentários, que pode ser usado em vez de uma mistura de tags HTML e JavaDoc @.
- Os mecanismos de correspondência de padrões foram aprimorados com suporte preliminar para o uso de tipos primitivos (int, byte, char e outros tipos básicos não-objetos) em todos os tipos de modelos, na instrução "instanceof" e em blocos "switch". switch (x.getStatus()) { case 0 -> “ok”; caso 1 -> “aviso”; caso 2 -> “erro”; case int i -> “status desconhecido:” + i; } if (i instância do byte b) {… b… }
- Adicionado suporte preliminar para usar uma única instrução "import module M" para importar todos os pacotes exportados por um módulo especificado de uma só vez. A mudança simplifica significativamente a reutilização de bibliotecas modulares, permitindo incluir bibliotecas e classes sem determinar seu lugar na hierarquia de pacotes. Por exemplo, especificar “import module java.base” importará todos os 54 pacotes incluídos no módulo java.base, que anteriormente precisariam ser mencionados separadamente (“import java.io.*”, “import java.util.*”. ”etc.).
Uma segunda implementação preliminar da API Class-File é proposta para analisar, gerar e converter arquivos de classe Java. ClassFile cf = ClassFile.of(); ClassModel classModel = cf.parse(bytes); byte[] newBytes = cf.build(classModel.thisClass().asSymbol(), classBuilder -> { for (ClassElement ce : classModel) { if (!(ce instanceof MethodModel mm && mm.methodName().stringValue(). começaCom("depurar"))) { classBuilder.with(ce);
- A oitava visualização da API Vector fornece funções para cálculos vetoriais que são executados usando instruções vetoriais em processadores x86_64 e AArch64 e permitem que operações sejam aplicadas simultaneamente a vários valores (SIMD). Ao contrário dos recursos fornecidos no compilador HotSpot JIT para autovetorização de operações escalares, a nova API torna possível controlar explicitamente a vetorização para processamento paralelo de dados.
- Adicionados métodos format, printf, readPassword e readLine à classe java.io.Console para formatar, exibir e ler texto com base na localidade selecionada. System.console().printf(Locale.FRANCE, "%1$tY-%1$tB-%1$te %1$tA", new Date()) 2024/16/XNUMX
- Foi adicionada uma segunda implementação de visualização da API Stream estendida que oferece suporte à definição de suas próprias operações intermediárias, o que pode ser útil em casos em que as operações intermediárias integradas existentes não são suficientes para a transformação de dados desejada. Os manipuladores nativos são conectados usando a nova operação intermediária Stream::gather(Gatherer), que processa elementos de fluxo aplicando a eles um manipulador especificado pelo usuário. jshell> Stream.of(1,2,3,4,5,6,7,8,9).gather(new WindowFixed(3)).toList() $1 ==> [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
- Adicionada uma terceira implementação preliminar de classes declaradas implicitamente e instâncias sem nome do método "principal", que pode dispensar declarações públicas/estáticas, passar uma matriz de argumentos e outras entidades associadas a uma declaração de classe. // era public class HelloWorld { public static void main(String[] args) { System.out.println("Olá mundo!"); } } // agora você pode void main() { System.out.println("Hello, World!"); }
- Adicionada uma segunda visualização de um recurso que permite aos construtores especificar expressões antes de chamar super(...), usado para chamar explicitamente o construtor de uma classe pai a partir de um construtor de classe herdada se essas expressões não se referirem a uma instância criada pelo construtor. class Outer { void olá() { System.out.println("Olá"); } class Interior { Interior() { olá(); super(); } } }
- Adicionada uma terceira implementação de visualização de valores com escopo, permitindo que dados imutáveis sejam compartilhados entre threads e dados trocados de forma eficiente entre threads filhos (os valores são herdados). Os valores com escopo estão sendo desenvolvidos para substituir o mecanismo de variáveis locais de thread e são mais eficientes ao usar um número muito grande de threads virtuais (milhares ou milhões de threads). A principal diferença entre valores com escopo e variáveis locais de thread é que os primeiros são gravados uma vez, não podem ser alterados no futuro e permanecem disponíveis apenas durante a execução do thread.
- Uma terceira visualização da API de simultaneidade estruturada foi proposta para teste, simplificando o desenvolvimento de aplicativos multithread, processando múltiplas tarefas executadas em threads diferentes como um único bloco.
- Os métodos de acesso à memória externa (fora da JVM) fornecidos pela classe sun.misc.Unsafe foram descontinuados e agendados para remoção. Para acessar a memória off-heap e interagir com código externo, é recomendado usar a API VarHandle e a API FFM (Foreign Function & Memory).
Adicionalmente, podemos destacar a publicação de uma atualização na plataforma de criação de aplicações com interface gráfica JavaFX 23 e a inclusão do compilador GraalVM JIT no Oracle JDK 23 principal.
Também é apresentada uma nova versão da máquina virtual universal GraalVM, que suporta a execução de aplicações em JavaScript (Node.js), Python, Ruby, R, quaisquer linguagens para JVM (Java, Scala, Clojure, Kotlin) e linguagens para o qual o bitcode LLVM pode ser gerado (C, C++, Rust). Além de oferecer suporte ao JDK 23, a nova versão otimiza o consumo de memória e o tamanho do código executável, e oferece suporte completo a ferramentas para incorporar Python e WebAssembly em código Java usando compilação JIT.
Fonte: opennet.ru
