instrução switch | mudar expressão

Ao escrever código com muitas condições, certamente você usou uma instrução if-else ou switch . Mas essa alternativa ao if-else tem desvantagens. Algumas pessoas até chamaram a instrução switch de "antipadrão".

Mas há uma boa notícia: as novas versões do Java trouxeram muitas mudanças na sintaxe da linguagem, e uma dessas mudanças afeta o switch . Intrigado? Então vamos mergulhar.

Para começar, vale esclarecer por que switch é um antipadrão. Considere o seguinte código:

switch (condition) {
    case "DECEMBER":
        seasonNumber = 1;
        break;
    case "JANUARY":
        seasonNumber = 1;
        break;
    case "FEBRUARY":
        seasonNumber = 1;
        break;
    default:
        seasonNumber = 0;
}

Ok, ainda não está totalmente claro por que esse é um "antipadrão".

Mas e se adicionarmos mais blocos case e agora o código ficar assim:

switch (condition) {
    case "DECEMBER":
        seasonNumber = 1;
        break;
    case "JANUARY":
        seasonNumber = 1;
        break;
    case "FEBRUARY":
        seasonNumber = 1;
        break;
    case “MARCH”:
        seasonNumber = 2;
        break;
    case “APRIL”:
        seasonNumber = 2;
        break;
    case “MAY”:
        seasonNumber = 2;
        break;
    default:
        seasonNumber = 0;
}

Vamos adicionar mais algumas linhas — o código cresce mais. Mais tarde, podemos adicionar mais e mais linhas, e ninguém nos impedirá de fazer isso.

Este é o cerne do problema: depois de criar inicialmente uma instrução switch compacta, adicionamos mais e mais código a ela, ocupando cada vez mais espaço — mais do que cabe na tela — e tornando o código inconveniente de ler e manter.

Diferença entre a instrução switch e a expressão switch

O Java 14 introduziu um switch novo e aprimorado. Não é uma instrução switch , mas sim uma expressão switch .

Qual é a diferença, você pergunta? A diferença é que uma instrução é uma instrução que executa um determinado conjunto de operações, mas uma expressão é um pedaço de código que executa algum cálculo e retorna um resultado.

Em outras palavras, agora você pode salvar o resultado de uma troca em uma variável.

Chega de falar. Agora vamos ver como é o novo switch :

var result = switch(month) {
     case DECEMBER, JANUARY, FEBRUARY -> 1;
     case MARCH, APRIL, MAY -> 2;
    case JUNE, JULY, AUGUST -> 3;
    case SEPTEMBER, OCTOBER, NOVEMBER -> 4;
    default -> 0;
};

A primeira coisa que chama a atenção é o quão compacto é o código. O código que costumava ocupar a maior parte da tela agora abrange algumas linhas e parece muito mais legível.

-> operador

Você também deve observar o operador -> (operador de seta). Você já deve estar familiarizado com ele se tiver experiência com expressões lambda.

Isso significa que agora você pode escrever uma opção legal no estilo de uma instrução lambda. O operador de seta indica que o compilador não prosseguirá para a próxima expressão case (se o bloco case atual não tiver uma instrução break ou return ), mas, em vez disso, fornecerá o valor da expressão à direita da seta.

Você também pode escrever um código que não seja uma expressão e simplesmente executar certas ações em vez de retornar qualquer coisa:

switch(condition) {
    case TRUE, FALSE -> System.out.println("True/false");

    default -> System.out.println("Another");
}

Observe que switch não possui mais uma instrução break . Ele foi removido no Java 13 e substituído por yield .

O que é rendimento e onde pode ser usado?

Quando um switch consiste em uma única linha, o próprio operador -> retorna o valor. Mas e se não tivermos uma, mas muitas linhas de código? Nesses casos, o operador de seta não retornará um valor, pois há várias linhas, não uma.

Talvez possamos usar return ? Afinal, ele é usado para retornar valores em Java. Infelizmente, não, o retorno não funcionará com um switch. Então o que podemos usar? Costumava haver break , mas foi removido no Java 13. Mas em seu lugar agora temos yield — uma nova palavra-chave que ajuda a retornar um valor de um switch. É análogo retornar instruções em métodos.

var result = switch(condition) {
//…
case "Hi" -> "greeting"
//…
};

Este código contém uma única linha e o operador -> retornará "saudação".

Mas quando temos um bloco de código:

var result = switch(condition) {
//…
case "Hi" -> {
// Your code
 Here you need to return "greeting"
	}
};

A palavra-chave que o ajudará a retornar um valor é yield :

var result = switch(condition) {
//…
case "Hi" -> {
// Your code
 yield "greeting";

	}
};

yield foi adicionado no Java 13 para casos em que temos mais de uma linha de código em um bloco case e precisamos retornar um resultado.

Você provavelmente está ansioso para experimentar a nova opção em seu código, mas lembre-se de que precisa do Java 14 ou superior para fazer isso. Com versões anteriores, esta opção só estará disponível se você especificar o sinalizador "--enable-preview" na linha de comando, pois antes da versão 14 fazia parte da visualização técnica, não uma parte completa do idioma.

É tudo por agora! Vê você!