Java 26: Pattern Matching Avançado na Prática (Guards, Record Patterns e Muito Mais)

Se você ainda usa isso:

if (obj instanceof User) {
    User user = (User) obj;
}

Você tá ficando pra trás.

Java evoluiu — e muito — com Pattern Matching. Hoje dá pra escrever código mais limpo, mais seguro e com menos boilerplate.

E não é teoria… é prática do dia a dia.

1. Pattern Matching básico (recap rápido)

Antes de ir pro avançado, lembra disso:

if (obj instanceof User user) {
    System.out.println(user.getName());
}

• já elimina cast manual

• código mais limpo

• menos erro

2. Pattern Matching com Guards (o pulo do gato)

Aqui começa a ficar interessante.

Antes (feio e verboso):

if (obj instanceof User) {
    User user = (User) obj;
    if (user.getAge() > 18) {
        System.out.println("Adulto");
    }
}

Agora com Guard:

if (obj instanceof User user && user.getAge() > 18) {
    System.out.println("Adulto");
}

isso aqui é o famoso guard clause no pattern matching

Uso real

if (obj instanceof Order order && order.getTotal() > 1000) {
    applyDiscount(order);
}

• código direto

• sem if aninhado

• fácil de ler

3. Switch com Pattern Matching (nível profissional)

Aqui o Java começou a ficar elegante de verdade.

Exemplo:

static String process(Object obj) {
    return switch (obj) {
        case String s -> "Texto: " + s;
        case Integer i -> "Número: " + i;
        case User u -> "Usuário: " + u.getName();
        default -> "Desconhecido";
    };
}

• sem cast

• sem if/else gigante

• sem bagunça

4. Guards dentro do switch

Agora junta tudo:

static String checkUser(Object obj) {
    return switch (obj) {
        case User u && u.getAge() < 18 -> "Menor de idade";
        case User u && u.getAge() >= 18 -> "Adulto";
        default -> "Outro tipo";
    };
}

isso aqui substitui MUITA lógica espalhada

5. Record Patterns (absurdo de útil)

Se você usa record, isso aqui é ouro.

Exemplo:

record User(String name, int age) {}

Pattern Matching direto:

if (obj instanceof User(String name, int age)) {
    System.out.println(name + " tem " + age + " anos");
}

• destruturação automática

• sem getter

• sem código repetido

6. Record + Guard juntos

Aqui vira arma de produção:

if (obj instanceof User(String name, int age) && age > 18) {
    System.out.println(name + " é adulto");
}

7. Pattern Matching aninhado (nível avançado)

Agora pensa em objeto complexo:

record Address(String city) {}
record User(String name, Address address) {}

Uso:

if (obj instanceof User(String name, Address(String city))) {
    System.out.println(name + " mora em " + city);
}

• destruturação profunda

• sem acessar manualmente cada nível

8. Aplicação real (código de verdade)

Exemplo: processamento de eventos

public String handleEvent(Object event) {
    return switch (event) {
        case User(String name, int age) && age < 18 -> "Usuário menor: " + name;
        case User(String name, int age) -> "Usuário adulto: " + name;
        case Order order && order.getTotal() > 1000 -> "Pedido VIP";
        case Order order -> "Pedido comum";
        default -> "Evento desconhecido";
    };
}

isso aqui em sistema real evita MUITO if/else

Erros comuns (que você deve evitar)

• Usar pattern matching só pra “achar bonito”

• Colocar lógica demais dentro do switch

• Ignorar default

• Misturar com código legado bagunçado

Quando usar (e quando NÃO usar)

Use quando:

• precisa tratar múltiplos tipos

• quer código mais limpo

• trabalha com DTOs/records

Evite quando:

• lógica é muito complexa

• vira um switch gigante impossível de manter

Dica de senior (vale ouro)

Pattern Matching não é só sintaxe nova.

é uma forma de pensar o código

Se você usar bem:

• reduz bugs

• melhora leitura

• facilita manutenção

Conclusão

Java 26 trouxe maturidade de linguagem.

Pattern Matching hoje é:

• ✔ mais limpo

• ✔ mais seguro

• ✔ mais expressivo

E sim — isso aqui já é padrão em código moderno.

Se você não estiver usando… tá ficando pra trás.