A evolução do switch no Java: do statement ao pattern matching

A evolução do switch no Java ilustra como a linguagem vem se adaptando para escrever código mais conciso, seguro e expressivo. Inicialmente concebido como um simples mecanismo de controle de fluxo, o switch passou por diversas transformações – do tradicional switch statement ao moderno switch expression com pattern matching – ampliando significativamente suas capacidades e flexibilidade.

1. Switch Statement Clássico

Nas versões iniciais do Java, o switch era utilizado para testar uma variável contra um conjunto fixo de valores constantes. Ele aceitava tipos primitivos (como int, char), enum e, posteriormente, String.

Embora funcional, exigia muito código repetitivo e atenção com o uso do break, que evitava o fall through – quando a execução continua no próximo case mesmo após encontrar um correspondente.

String nivel = "intermediário";
switch (nivel) {
    case "iniciante":
        System.out.println("Você está começando.");
        break;
    case "intermediário":
        System.out.println("Você já tem alguma experiência.");
        break;
    case "avançado":
        System.out.println("Você domina a linguagem!");
        break;
    default:
        System.out.println("Nível desconhecido.");
}

Problemas comuns:

• Esquecer do break, gerando bugs difíceis de rastrear.
• Sintaxe extensa e repetitiva.
• Falta de suporte a retorno direto de valores.

2. Switch Expression (Java 12+ / Java 14)

A partir do Java 12, e estabilizado no Java 14 com a JEP 361, foi introduzido o conceito de switch expressions. Com ele, o switch deixa de ser apenas um comando e passa a ser também uma expressão que retorna valores.

Vantagens:

• Sintaxe concisa: -> elimina o break e evita fall through.
• Retorno de valores: pode-se armazenar diretamente o resultado do switch.

int mes = 2;
String nomeMes = switch (mes) {
    case 1 -> "Janeiro";
    case 2 -> "Fevereiro";
    case 3 -> "Março";
    default -> "Mês inválido";
};
System.out.println("O mês é: " + nomeMes);

Também é possível usar blocos para lógica mais complexa:

int numero = 5;
String resultado = switch (numero) {
    case 1, 2, 3 -> "Baixo";
    case 4, 5, 6 -> {
        System.out.println("Faixa intermediária");
        yield "Médio";
    }
    default -> "Alto";
};

3. Pattern Matching para Switch (Java 17+ / Java 21)

A terceira etapa da evolução é ainda mais poderosa: o pattern matching para switch, introduzido em preview no Java 17 e estabilizado no Java 21 com a JEP 441. Essa funcionalidade transforma o switch em uma ferramenta capaz de verificar padrões de tipo, extrair variáveis, e aplicar condições diretamente nos cases.

Novos recursos com pattern matching:

• Testar tipos dinamicamente: sem necessidade de instanceof + cast.
• Extração de variáveis inline: o valor é automaticamente atribuído ao tipo correto.
• Guards (when): permitem adicionar condições extras.
• Tratamento de null diretamente.
• Desconstrução de records.

Exemplo prático:

Object valor = 42;
String resultado = switch (valor) {
    case Integer num && num > 50 -> "Número grande";
    case Integer num -> "Número pequeno ou médio";
    case String s when s.length() > 3 -> "Texto longo";
    case String s -> "Texto curto";
    case null -> "Valor nulo";
    default -> "Outro tipo";
};
System.out.println("Resultado: " + resultado);

Com record:

record Pessoa(String nome, int idade) {}

Object obj = new Pessoa("Ana", 30);

String descricao = switch (obj) {
    case Pessoa(String nome, int idade) when idade >= 18 -> nome + " é maior de idade.";
    case Pessoa(String nome, int idade) -> nome + " é menor de idade.";
    default -> "Tipo desconhecido.";
};

Comparação de Sintaxe:

Quando usar cada um?

A transformação do switch no Java reflete o compromisso da linguagem com a evolução sem perder compatibilidade. De uma estrutura limitada e propensa a erros, o switch se tornou uma ferramenta moderna, expressiva e versátil.