DEV Community: Lorena Gomes

Evolução do "switch case" do Java 8 ao Java 21 🎯

Lorena Gomes — Sat, 12 Oct 2024 08:30:56 +0000

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! 👩‍💻

Noções de HTTP

Lorena Gomes — Mon, 06 Jun 2022 16:22:13 +0000

HTTP:

O HTTP é o protocolo mais importante da internet, ele é utilizado pela grande maioria das aplicações web e ele independe da plataforma de desenvolvimento;

HTTP é a sigla de "HyperText Transfer Protocol", ou seja, um protocolo para transferência de texto (puro).

Esse protocolo determina as regras da comunicação entre o cliente e servidor na internet. Sendo o cliente e o servidor conceitos que representam "aquele que faz a requisição (pergunta)" e "aquele que responde a essa requisição", é sempre o cliente que inicia a comunicação. A comunicação em HTTP é conhecida como Request-Response. Como exemplo podemos citar um navegador que envia uma requisição e uma API - que independente da linguagem utilizada- que responde essa requisição.

O HTTP é stateless, ou seja, ele por si só não guardar o estado das requisições enviadas, dessa forma é necessário fazer o envio de todas as informações que em cada sessão, durante a navegação pelo site.

Por exemplo ao fazer o login em site de notícias seria necessário envia a requisição com e-mail e senha ao se logar, quando fosse navegar pelas notícias seria necessário enviar novamente essas informações a cada notícia que você entrasse para ler, isso além de muito trabalhoso também seria inseguro ficar trafegando com informações "sensíveis" a cada sessão, para resolver essa questão são utilizado os cookies.

Mas o que são os cookies? Se tratando de HTTP podemos dizer que os cookies são arquivos que guardam um token de identificação do cliente, no navegador, para que não seja necessário o envio de todas informações a cada requisição, com funciona ao se logar o cliente envia o e-mail e senha (por exemplo) o servidor ao receber essas informações gera um token (uma chave de números aleatórios) que identifica esse cliente e devolve ao cliente "dizendo 'Olha essa é sua identificação nas próximas requisições é só me enviar esse token que eu já vou saber que é você, ok!".

HTTPS:

Ao se enviar dados em uma requisição HTTP ela pode passar por diversos servidores até chegar no destino final e isso deixa os dados enviados expostos por se tratar de uma transferência de texto puro, devido a demanda de proteger os dados que trafegam na internet foi criado o HTTPS, que é o HTTP comum associado a uma camada de segurança/criptografia, que é a SSL/TSL (Secure Sockets Layer/ Transport Layer Security), na prática o que ocorre é que os dados não são mais enviados como texto puro e sim como um texto criptografado, sendo que apenas o servidor de destino final tem a chave para acessar esse texto.

A criptografia utilizada pela SSL/TSL se baseia em pares de chaves públicas e privadas. As chaves públicas ficam a disposição do cliente e é ela que irá criptar os dados enviados, a chave privada fica de posse exclusivamente do servidor e ela será utilizada para descriptografar a mensagem recebida. As chaves são geradas por uma autoridade certificadora para garantir essa segurança e legitimidade, ela emite um certificado digital que atrela a identidade do site as chaves geradas, esse certificado tem validade.

HTTP/2:

O HTTP/2 é um update do HTTP, ele surgiu para adequar o protocolo para o cenário onde há uma quantidade muito maior de dados sendo trafegados pela rede, e a velocidade de acesso e segurança são pontos fundamentais. O HTTP/2 possui diversas tecnologias de compactação da requisição. Os dados da resposta são compactadas utilizando o GZIP (No servidor), as mensagens (enviada no headers) tanto da requesição quanto resposta passam a transportar dados binários e não mais o texto puro, além de binário elas são comprimidas usando um algoritmo chamado HPACK, fazendo com que o volume de dados trafegados diminua bastante, todas essas melhorias levam a um ganho de performance na comunicação cliente-servidor. Mas não para por ai, o HTTP/2 já tem uma atenção para segurança, por padrão ele exige a aplicação do TLS, ou seja, o HTTP/2 pega as informações altamente compactadas e criptografa antes do envio.

O HTTP/2 é stateful, ele guarda as informações do header no primeiro envio, não sendo necessário enviar todas as informações a cada requisição.