This content originally appeared on DEV Community and was authored by Lorena Gomes
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! 👩💻
This content originally appeared on DEV Community and was authored by Lorena Gomes
Lorena Gomes | Sciencx (2024-10-12T08:30:56+00:00) Evolução do “switch case” do Java 8 ao Java 21 🎯. Retrieved from https://www.scien.cx/2024/10/12/evolucao-do-switch-case-do-java-8-ao-java-21-%f0%9f%8e%af/
Please log in to upload a file.
There are no updates yet.
Click the Upload button above to add an update.