O switch é muito utilizado quando você precisa comparar um conjunto fixo e pequeno de valores, especialmente se forem valores constantes como String, Enum, ou classes seladas.
Além disso, ele é ideal para melhorar a legibilidade do código e pode oferecer vantagens de desempenho em relação ao if-else, dependendo do número de casos.

O uso do switch em Java evoluiu bastante desde a versão 8. Vou destacar as principais mudanças e melhorias introduzidas ao longo do tempo.

Java 8 (2014)

O switch era bem limitado e suportava apenas tipos primitivos como int, char, byte, short e suas respectivas classes wrapper (Integer, Character, etc.). Além disso, switch podia ser usado com Enum e String (introduzido no Java 7).

int day = 2;
switch (day) {
    case 1:
        System.out.println("Sunday");
        break;
    case 2:
        System.out.println("Monday");
        break;
    default:
        System.out.println("Invalid day");
}

O uso de break era obrigatório para evitar o fall-through (a execução continuava para o próximo caso, se o break fosse omitido).
O switch era usado apenas como declaração (statement), ou seja, ele não podia retornar diretamente valores.

Java 12 (2019)

Nessa versão o Java introduziu o conceito de switch expressions como uma funcionalidade experimental (preview), permitindo que o switch fosse usado tanto como declaração (statement) quanto como expressão. Isso trouxe duas grandes mudanças:

Setas (->): A sintaxe usando setas foi introduzida para substituir o uso do break, tornando o código mais conciso e legível.

Retorno de valor: Agora era possível retornar diretamente valores de um switch, transformando-o em uma expressão.

int day = 2;
String dayName = switch (day) {
    case 1 -> "Sunday";
    case 2 -> "Monday";
    case 3 -> "Tuesday";
    default -> "Invalid day";
};
System.out.println(dayName);  

// Output: Monday

Java 13 (2019)

O switch expressions continuou em modo preview, mas teve algumas melhorias. Agora, além da sintaxe com setas, era possível usar o yield para retornar valores, mesmo nas versões tradicionais (com blocos de código em vez de apenas setas).
O uso do yield foi necessário para permitir que blocos de código maiores pudessem ser usados dentro dos casos sem comprometer a clareza.

int day = 3;
String dayName = switch (day) {
    case 1: 
        yield "Sunday";
    case 2: 
        yield "Monday";
    case 3: 
        yield "Tuesday";
    default: 
        yield "Invalid day";
};
System.out.println(dayName);  

// Output: Tuesday

Java 14 (2020)

O switch expression saiu do modo preview e se tornou uma funcionalidade padrão, disponível para todos os desenvolvedores. Agora, além das melhorias de sintaxe e uso de yield, essa forma de switch passou a ser considerada estável e recomendada para casos que exigem retornos de valor.

Java 17 (2021)

O switch passou por melhorias adicionais para suportar novos tipos de dados e ser ainda mais flexível:

Suporte para classes seladas: O switch agora é otimizado para trabalhar com classes seladas (sealed classes), o que facilita a correspondência exata de tipos específicos.

Melhoria no tratamento de null: Agora é possível tratar explicitamente o valor null dentro de um switch, algo que antes gerava um erro de compilação.

sealed interface Shape permits Circle, Rectangle {}

final class Circle implements Shape {
    double radius;
}

final class Rectangle implements Shape {
    double width, height;
}

Shape shape = new Circle();

String result = switch (shape) {
    case Circle c -> "Circle with radius " + c.radius;
    case Rectangle r -> "Rectangle with width " + r.width + " and height " + r.height;
};
System.out.println(result);

String input = null;
String result = switch (input) {
    case null -> "Null value";
    case "Hello" -> "Greeting";
    case "Bye", "Byebye" -> "See you tomorrow!"
    default -> "Unknown input";
};
System.out.println(result);  

// Output: Null value

Java 20 (2023)

Houve o aperfeiçoamentos nas expressões de padrões, permitindo o uso do switch com padrões para fazer correspondências mais ricas e tipadas.
E a grande novidade foi a introdução de pattern matching no switch, ainda como recurso preview, permitiu usar padrões mais complexos com a capacidade de testar tipos.

static String formatterPatternSwitch(Object obj) {
    return switch (obj) {
        case Integer i -> String.format("int %d", i);
        case Long l    -> String.format("long %d", l);
        case Double d  -> String.format("double %f", d);
        case String s  -> String.format("String %s", s);
        default        -> obj.toString();
    };
}

Java 21 (2023)

Agora finalizado o pattern matching está disponível como recurso padrão no Java 21. Ele expande o uso do switch com a capacidade de combinar padrões de tipos diretamente nas expressões.
Nessa versão o compilador atua diretamente garantindo que todos os ramos de um switch que usa pattern matching sejam cobertos, reduzindo a chance de erros em tempo de execução.

public static String formatObject(Object obj) {
    return switch (obj) {
        case Integer i -> "It's an integer: " + i;
        case String s  -> "It's a string: " + s;
        case null      -> "It's null!";
        default        -> "It's another type: " + obj.toString();
    };
}

Realmente foram muitas mudanças ao longo das versões, o que torna o switch ainda mais atrativo.

Nos resta nos atualizar, colocar no código e aproveitar! 👩‍💻