La evolución del switch en Java: del statement al pattern matching

La evolución del switch en Java ilustra cómo el lenguaje se ha ido adaptando para escribir código más conciso, seguro y expresivo. Concebido inicialmente como un simple mecanismo de control de flujo, el switch ha pasado por diversas transformaciones — del tradicional switch statement al moderno switch expression con pattern matching — ampliando significativamente sus capacidades y flexibilidad.

1. Switch Statement Clásico

En las primeras versiones de Java, el switch se usaba para comparar una variable contra un conjunto fijo de valores constantes. Aceptaba tipos primitivos (como int, char), enum y, más adelante, String.

Aunque funcional, requería mucho código repetitivo y atención al uso del break, que evitaba el fall through — cuando la ejecución continúa en el siguiente case incluso después de encontrar una coincidencia.

String nivel = "intermedio";
switch (nivel) {
    case "principiante":
        System.out.println("Estás comenzando.");
        break;
    case "intermedio":
        System.out.println("Ya tienes algo de experiencia.");
        break;
    case "avanzado":
        System.out.println("¡Dominas el lenguaje!");
        break;
    default:
        System.out.println("Nivel desconocido.");
}

Problemas comunes:

• Olvidar el break, generando bugs difíciles de rastrear.
• Sintaxis extensa y repetitiva.
• Falta de soporte para retornar valores directamente.

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

A partir de Java 12, y estabilizado en Java 14 con la JEP 361, se introdujo el concepto de switch expressions. Con él, el switch deja de ser solo un comando y pasa a ser también una expresión que devuelve valores.

Ventajas:

• Sintaxis concisa: -> elimina el break y evita el fall through.
• Retorno de valores: se puede almacenar directamente el resultado del switch.

int mes = 2;
String nombreMes = switch (mes) {
    case 1 -> "Enero";
    case 2 -> "Febrero";
    case 3 -> "Marzo";
    default -> "Mes inválido";
};
System.out.println("El mes es: " + nombreMes);

También es posible usar bloques para lógica más compleja:

int numero = 5;
String resultado = switch (numero) {
    case 1, 2, 3 -> "Bajo";
    case 4, 5, 6 -> {
        System.out.println("Rango intermedio");
        yield "Medio";
    }
    default -> "Alto";
};

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

La tercera etapa de esta evolución es aún más poderosa: el pattern matching para switch, introducido en preview en Java 17 y estabilizado en Java 21 con la JEP 441. Esta funcionalidad convierte al switch en una herramienta capaz de verificar patrones de tipo, extraer variables y aplicar condiciones directamente en los cases.

Nuevas capacidades con pattern matching:

• Probar tipos dinámicamente: sin necesidad de instanceof + cast.
• Extracción de variables inline: el valor se asigna automáticamente al tipo correcto.
• Guards (when): permiten agregar condiciones adicionales.
• Manejo de null directamente.
• Deconstrucción de records.

Ejemplo práctico:

Object valor = 42;
String resultado = switch (valor) {
    case Integer num && num > 50 -> "Número grande";
    case Integer num -> "Número pequeño o mediano";
    case String s when s.length() > 3 -> "Texto largo";
    case String s -> "Texto corto";
    case null -> "Valor nulo";
    default -> "Otro tipo";
};
System.out.println("Resultado: " + resultado);

Con un record:

record Persona(String nombre, int edad) {}

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

String descripcion = switch (obj) {
    case Persona(String nombre, int edad) when edad >= 18 -> nombre + " es mayor de edad.";
    case Persona(String nombre, int edad) -> nombre + " es menor de edad.";
    default -> "Tipo desconocido.";
};

Comparación de sintaxis:

¿Cuándo usar cada uno?

La transformación del switch en Java refleja el compromiso del lenguaje con evolucionar sin perder compatibilidad. De una estructura limitada y propensa a errores, el switch se ha convertido en una herramienta moderna, expresiva y versátil.