Java: Mais Simples e Poderoso

9/20/2025•Michael

E aí, Aqui é o Bullet, trazendo um artigo fresquinho sobre as mudanças no Java 25, que acabou de sair do forno em setembro de 2025. Nada de formalidade chata, só papo reto, exemplos práticos e um tom de quem tá batendo papo no café enquanto "coda fofo", é o javinha Pae

Java 25 é a nova LTS (Long-Term Support), o que significa que ela vai te acompanhar por um bom tempo. Vamos mergulhar nas novidades?

Vou dividir em seções pra ficar fácil de navegar, cobrindo linguagem, bibliotecas, performance e mais.

Pegue seu café e bora!

Linguagem Java: Mais Simples e Poderosa, Como Sempre

O Java tá evoluindo pra ser mais amigável pros devs iniciantes e pros veteranos que querem codar rápido. Aqui vão as principais mudanças na linguagem.

Tipos Primitivos em Patterns, Instanceof e Switch (JEP 507 - Terceira Preview)

Sabe aquela dor de cabeça com patterns que só funcionavam bem com objetos?

Agora, tipos primitivos (como int, long) entram na dança em patterns, instanceof e switch. Isso reduz boilerplate e deixa o código mais expressivo. Imagina checar se um objeto é um int diretamente!

Exemplo rapidinho:

static void testa(Object obj) {
    if (obj instanceof int i) {
        System.out.println("É um int: " + i);
    }
}

É preview ainda, mas já dá pra brincar e ver o potencial.

Importações de Módulos (JEP 511 - Finalizada)

Cansado de importar pacotes um por um de um módulo? Agora você pode fazer import module java.base; e pronto, todos os pacotes exportados vêm junto.

Perfeito pra reutilizar bibliotecas modulares sem bagunça. Se tiver ambiguidade (tipo Date do util vs sql), aí sim importa específico.

Exemplo:

import module java.base;

public class Main {
    public static void main(String[] args) {
        Date d = new Date();
        System.out.println("Data resolvida: " + d);
    }
}

Isso simplifica a vida, né?

Arquivos Fonte Compactos e Main de Instância (JEP 512 - Finalizada)

Pra quem tá começando ou quer prototipar rápido, agora dá pra escrever programas sem classes explícitas ou métodos estáticos.

O main pode ser de instância, e o código fica mais "script-like".

Ideal pra testes ou scripts simples.

Exemplo minimalista:

void main() {
    System.out.println("Olá do Java 25!");
}

É como se o Java estivesse dizendo: "Relaxa, não precisa de tanta cerimônia."

Corpos de Construtores Flexíveis (JEP 513 - Finalizada)

Antes, você não podia colocar código antes do super() ou this() no construtor.

Agora pode! Isso permite validações ou inicializações antes de chamar o pai, sem vazar referências prematuras.

Mais seguro e natural.

Exemplo:

class Funcionario extends Pessoa {
    final String nome;
    Funcionario(String nome, int idade) {
        if (idade < 18 || idade > 67)
            throw new IllegalArgumentException("Idade deve estar entre 18 e 67");
        super(idade);
        this.nome = nome;
    }
}

Adeus workarounds esquisitos!

Concorrência e Threads: Mais Estruturada e Eficiente

Java continua investindo em threads virtuais e concorrência moderna.

Essas features vão te ajudar a lidar com tarefas paralelas sem dor de cabeça.

Concorrência Estruturada (JEP 505 - Quinta Preview)

Trata grupos de tarefas relacionadas como uma unidade só.

Facilita lidar com erros, cancelamentos e observabilidade.

Agora, o StructuredTaskScope é aberto via métodos estáticos, sem construtores públicos.

Exemplo:

import java.util.concurrent.StructuredTaskScope;

public class ExemploEstruturado {
    static String buscaUsuario() { return "Alice"; }
    static String buscaPedido() { return "Pedido#42"; }
    public static void main(String[] args) throws Exception {
        try (var scope = StructuredTaskScope.<String>open()) {
            var tarefaUsuario = scope.fork(() -> buscaUsuario());
            var tarefaPedido = scope.fork(() -> buscaPedido());
            scope.join();
            System.out.println(tarefaUsuario.get() + " - " + tarefaPedido.get());
        }
    }
}

É como orquestrar uma banda: tudo no ritmo certo.

Scoped Values (JEP 506 - Finalizada)

Alternativa imutável e thread-safe ao ThreadLocal, perfeita pra threads virtuais.

Compartilha dados imutáveis entre threads pai e filhos com custo baixo.

Exemplo:

import java.lang.ScopedValue;
import java.util.concurrent.Executors;

public class ExemploScoped {
    static final ScopedValue<String> USUARIO = ScopedValue.newInstance();
    public static void main(String[] args) {
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            executor.submit(() -> ScopedValue.where(USUARIO, "Alice").run(() -> {
                System.out.println("Usuário: " + USUARIO.get());
            }));
            Thread.sleep(200);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

Mais leve que ThreadLocal, e sem surpresas.

Valores Estáveis (JEP 502 - Preview)

Objetos imutáveis tratados como constantes pelo JVM, pra otimizações de performance. Tipo um Optional mais flexível pra caching ou lazy init.

Exemplo:

import java.lang.StableValue;

public class ExemploEstavel {
    public static void main(String[] args) {
        var saudacao = StableValue.<String>of();
        String mensagem = saudacao.orElseSet(() -> "Olá do StableValue!");
        System.out.println(mensagem);
    }
}

Útil pra singletons ou pools de objetos.

Segurança e Cripto: Mais Moderno e Fácil

Java 25 não esqueceu da segurança, com features pra lidar com chaves e derivadas.

Codificações PEM de Objetos Criptográficos (JEP 470 - Preview)

API simples pra codificar/decodificar chaves, certs e listas de revogação em formato PEM. Suporta PKCS#8, X.509 e mais.

Exemplo básico:

import java.security.KeyFactory;
import java.security.PublicKey;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;

public class ExemploPEM {
    public static void main(String[] args) {
        String pem = "-----BEGIN PUBLIC KEY-----\n...";
        // Lógica pra parsear e usar
    }
}

Era uma falta que tava doendo, agora tá aí!

API de Funções de Derivação de Chaves (JEP 510 - Finalizada)

Algoritmos pra derivar chaves adicionais de uma chave secreta.

Prepara pro mundo quântico, com suporte a HMAC e Argon2.

Bom pra KEMs e protocolos de alto nível.

Performance e JVM: Otimizações que Fazem Diferença

Aqui é onde o Java brilha pros apps pesados.

Cabeçalhos de Objetos Compactos (JEP 519 - Produto)

Reduz o tamanho dos headers de objetos na heap, de 96-128 bits pra 64 bits em 64-bit. Menos memória usada, melhor densidade e localidade de dados. Desligado por default, mas pode virar padrão no futuro.

API de Vetores (JEP 508 - Décima Incubadora)

Computações vetoriais que compilam pra instruções otimizadas em CPUs suportadas. Agora linka com libs nativas de math e suporta Float16.

Outras de Performance

  • JFR CPU-time Profiling (JEP 509): Profiling mais preciso no Linux.
  • Ahead-of-Time Ergonomics e Profiling (JEPs 514 e 515): Acelera startup com caches AOT e perfis de métodos.
  • JFR Cooperative Sampling e Method Timing (JEPs 518 e 520): Melhora estabilidade e tracing sem instrumentação.
  • Generational Shenandoah (JEP 521): GC mais estável e eficiente.

Bibliotecas Core: Pequenas Grandes Mudanças

  • Adicionado getChars em CharSequence pra leitura bulk.
  • Propriedade stdin.encoding pra charset de System.in.
  • Limites em responses HTTP pra evitar overflow.
  • ForkJoinPool agora implementa ScheduledExecutorService.
  • Inflater/Deflater como AutoCloseable.

E mais tweaks em ZIP, JAR e HTTP...

Deprecações e Remoções

  • Algumas APIs antigas depreciadas, como velhos construtores em StructuredTaskScope.
  • Nada muito drástico removido, mas fique de olho nos release notes pra migrações.

Conclusão: Java 25 Vale a Pena?

Java 25 é tipo um upgrade suave, focado em produtividade, performance e segurança.

Não tem uma "killer feature", mas um monte de melhorias que somam pra um código mais limpo e apps mais rápidos. Se você tá em Java 21, migre pra essa LTS.

Teste as previews e veja o que acha! Qualquer dúvida, me chama.

Quer dar uma lida na doc? tá na mão: https://www.oracle.com/java/technologies/javase/25all-relnotes.html