Evolução da linguagem Java (parte 3)

Neste artigo damos continuidade à nossa análise histórica sobre os recursos que cada versão do Java. trouxe para tornar o código mais limpo e simples para o desenvolvedor.

Se você caiu de paraquedas aqui e ainda não leu a primeira parte, clique aqui.

Java 11

O Java 11 trouxe várias melhorias pontuais. Entre elas, novos métodos em String(isBlank, lines, strip, stripLeading, stripTrailing e repeat), a possibilidade de usar var em parâmetros de expressões lambda e um novo HttpClient moderno e menos verboso.

Novos métodos em String

O isBlank(), verifica se a string é vazia ou contém apenas espaços em branco:

String texto = "  Olá  \nMundo  ";
String textoVazio = "        ";

System.out.println(texto.isBlank());  //false
System.out.println(textoVazio);       //true

O método lines() deixa o código mais limpo quando precisamos quebrar uma string em várias linhas.

String texto = "Linha 1\nLinha 2\nLinha 3";

String[] linhas = texto.split("\\R"); // regex para qualquer quebra de linha
for (String l : linhas) {
    System.out.println(l);
}

// Java 11
texto.lines().forEach(System.out::println);

Os métodos strip, stripLeading e stripTrailing nasceram para substituir o nosso antigo método trim.

String s = "   Java   ";
System.out.println("[" + s.strip() + "]");  // [Java]
System.out.println("[" + s.stripLeading() + "]");   // [Java   ]
System.out.println("[" + s.stripTrailing() + "]");  // [   Java]

O trim não remove todos os tipos de espaço Unicode, apenas espaço comum, tab, quebra de linha e outros (menor ou igual a U+0020). Já o strip remove todos os espaços em branco Unicode do início e do fim.

String texto = "   Olá Mundo   ";
String textoUnicode = "\u2002Olá Mundo\u2002"; // contém espaço Unicode (EN SPACE)

System.out.println("[" + texto.trim() + "]");   // [Olá Mundo]
System.out.println("[" + texto.strip() + "]");  // [Olá Mundo]

// Diferença com Unicode
System.out.println("[" + textoUnicode.trim() + "]");  // [ Olá Mundo ]  (não removeu)
System.out.println("[" + textoUnicode.strip() + "]"); // [Olá Mundo]    (removeu)

O método repeat(int count), facilita muito a repetição de strings — algo que antes exigia laços ou utilitários.

// Antes - Usando StringBuilder
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 5; i++) {
    sb.append("=");
}
String repetido = sb.toString();

// Antes - Usando Collections.nCopies
String repetido = String.join("", Collections.nCopies(5, "="));

// Java 11
String repetido = "=".repeat(5);

Novo HttpClient

Este novo client, além de reduzir a verbosidade, trouxe suporte nativo a HTTP/2, eliminando a necessidade de bibliotecas de terceiros para casos simples.

// Java 11
HttpClient client = HttpClient.newHttpClient();
HttpRequest req = HttpRequest.newBuilder(URI.create("https://httpbin.org/get")).build();
HttpResponse<String> resp = client.send(req, HttpResponse.BodyHandlers.ofString());

System.out.println(resp.body());

Java 12, 13 e 14.

Nessas versões novos recursos foram adicionados, como Switch Expressions, Text Blocks, Records e Pattern Matching para instanceof.
Entretanto, todos ainda estavam sinalizados como preview. Vou falar especificamente de cada um deles nas versões em que se tornaram final.

Os métodos em String foram muito bem-vindos, mas na época eu esperava ainda mais.
Quando li sobre a novidade, imaginei que o Java finalmente eliminaria a necessidade de bibliotecas de terceiros (como a StringUtils, do Apache ou do Spring).
Ainda assim, esses métodos ajudam a reduzir linhas de código.

O uso de var em parâmetros de lambda, na minha visão, é desnecessário — acaba deixando o código mais verboso sem trazer ganho real.

Já o novo HttpClient chegou um pouco atrasado. Enquanto ele não existia, bibliotecas de terceiros já ofereciam suporte ao HTTP/2 há anos, e em grandes projetos ainda prefiro soluções maduras como OpenFeign ou OkHttp.

👉Concorda com a minha análise? Se lembrar de algum recurso relevante que não citei, compartilhe nos comentários.

Gostou deste artigo? Me siga e fique atento para a terceira parte, onde vamos explorar o que veio do Java 15 em diante.