Search for a command to run...
Conheça as grandes melhorias de cada versão do Java
I'm Sassine, Java Specialist and Engineering Manager at NTT DATA, based in Brazil. My main strengths are architecture, performance, quality and agility in the Java and Spring universe with AWS.
Sou Sassine, especialista em Java e gerente de engenharia da NTT DATA, com sede no Brasil. Meus principais pontos fortes são arquitetura, desempenho, qualidade e agilidade no universo Java e Spring com AWS.
No comments yet. Be the first to comment.
A nova abordagem recomendada pelo Spring para fazer chamadas de API de forma reativa ou bloqueante
Percorra, manipule, converta... suas listas de forma performática com Stream
Introdução Sempre que estou entrevistando um novo candidato eu o questiono sobre o uso ou conhecimento do Optional, e quase sempre ouço a mesma resposta "Já utilizei, quando usei o JPA "😢 📦 Caso queira acompanhar a classe completa enquanto lê o art...
Principalmente os dados de entrada de saída de sua API.
Vou apresentar as grandes melhorias de cada versão do Java, agora oferece suporte total para lambdas , programação funcional, digite inferência via var, coleções imutáveis com construtores simples e mais performáticos e string multi-linhas.... além disso, existem novos recursos empolgantes, como classes de dados (record), switch 2.0 e sealed classes.
Programação Funcional
No Java 8, programação funcional e lambdas foram adicionados como recursos de linguagem. Os dois paradigmas principais de programação funcional estão valores imutáveis e elevando funções para cidadãos de primeira classe.
Os dados passam por um pipeline de etapas de modificação, onde cada etapa pega alguma entrada e mapeia para uma nova saída, que podem ser usadas com Streams e Optional .
Para um programa de computador comum, geralmente você precisa trabalhar com uma lista de valores e realizar uma determinada transformação em cada valor . Antes do Java 8, você tinha que usar um for loop para essa transformação, mas a partir de agora, você pode usar Streams da seguinte maneira:
Stream.of("Oi", "E ai")
.map(s -> s + " Sassine")
.forEach(System.out::println);
> Oi Sassine
> E ai Sassine
A função map recebe como entrada um lambda, que será aplicado a todos os elementos do fluxo.
Streams pode trabalhar em Lists, Sets e Maps (via transformação). Graças ao Streams, você pode se livrar de praticamente todos os loops em seu código! top né ?
Quiser saber mais do Stream, da uma olhada neste post - Java Stream - Domine as listas/coleções de uma vez por todas; ✨
Outro problema comum em Java eram as exceções de ponteiro nulo. Portanto, Java introduziu Optional – que envolve uma referência que pode ou não ser nula. A aplicação de atualizações a este opcional pode ser feita de maneira funcional:.
Optional.of(new Random().nextInt(10))
.filter(i -> i % 2 == 0)
.map(i -> "número é par: " + i)
.ifPresent(System.out::println);
> número é par: 6
No trecho acima, criamos um número aleatório, envolvemos dentro de um objeto opcional e, em seguida, imprimimos o número apenas se for par.
Quiser saber mais do Optional, da uma olhada neste post - Chega de NullPointer, comece a utilizar Optional em sua codificação!; ✨
Finalmente, temos um REPL para Java, e seu nome é JShell ! 😊 Em poucas palavras, JShell permite experimentar trechos de Java sem escrever e compilar uma classe Java completa. Em vez disso, você pode executar um comando por vez e ver o resultado imediatamente. Aqui está um exemplo simples:
$ <JDK_HOME>/bin/jshell > System.out.println("Sassine.dev")
> Sassine.dev
Pessoas familiarizadas com linguagens interpretadas como JavaScript ou Python tiveram o prazer de um REPL por muito tempo, mas até agora, esse recurso estava faltando em Java. JShell permite definir variáveis , mas também entidades mais complexas, como funções multilinhas , classes e executar loops.
Além disso, o JShell oferece suporte ao preenchimento automático, o que é útil se você não souber os métodos exatos oferecidos por uma determinada classe Java
A inicialização simples do Lists está faltando no Java há muito tempo, mas esses tempos acabaram agora. 😅 Anteriormente, você tinha que fazer algo assim:
jshell> List<Integer> list = Arrays.asList(1, 2, 3, 4)
list ==> [1, 2, 3, 4]
# Isso agora é simplificado da seguinte forma:
jshell> List<Integer> list = List.of(1, 2, 3, 4)
list ==> [1, 2, 3, 4]
Este of(...) método sofisticado existe para List , Set e Map . Todos eles criam um objeto imutável em apenas uma linha simples de código.
Java 10 introduziu a nova palavra-chave var que permite omitir o tipo de uma variável.
var baos = new ByteArrayOutputStream();
Esse recurso ajuda a reduzir o código clichê e melhorar a legibilidade. Porém, há algumas limitações: você só pode usar var dentro dos corpos dos métodos, e o compilador inferirá o tipo em tempo de compilação, então tudo ainda está estaticamente tipado.
Anteriormente, quando você escrevia um programa Java simples consistindo em um arquivo, era necessário primeiro compilar o arquivo com javac e depois executá-lo java. No Java 11, você pode executar as duas etapas com um comando.
Classe exemplo:
public class TesteCompile {
public static void main(String[] args) {
System.out.println("olá mundo");
}
}
Executando a classe:
java ./TesteCompile.java
> olá mundo
Para programas iniciais simples ou experimentos que consistem em apenas uma classe Java, esse recurso para iniciar arquivos de código-fonte único tornará sua vida mais fácil.
Aqui está uma demonstração rápida de como a expressão difere da antiga instrução switch.
A antiga instrução switch define o fluxo do programa:
jshell> var i = 2
jshell> String s;
jshell> switch(i) {
...> case 1: s = "um"; break;
...> case 2: s = "dois"; break;
...> case 3: s = "três"; break;
...> default: s = "número desconhecido";
...> }
jshell> s
s ==> "dois"
Agora a nova expressão switch retorna um valor:
jshell > var i = 2 ;
jshell > var x = switch (i) {
... > case 1 -> "um";
... > case 2 -> "dois";
... > case 3 -> "três";
... > default -> "número desconhecido";
... > } ;
x ==> "dois"
Para resumir, a instrução switch antiga é para o fluxo do programa e a nova expressão switch resolve para um valor.
Observe que essa nova instrução switch é uma espécie de função de mapeamento : há uma entrada (no caso acima i) e há uma saída (aqui x). Na verdade, esse é um recurso de correspondência de padrões que ajuda a tornar o Java mais compatível com os princípios de programação funcional . Uma instrução switch semelhante está disponível no Scala há algum tempo.
Algumas coisas a serem observadas:
Para habilitar este recurso com Java 12, use --enable-preview --source 12
Você já teve que definir uma string longa de várias linhas como JSON ou XML? Até agora, você provavelmente esmagaria tudo em uma linha e usaria caracteres de nova linha \n, mas isso torna a String muito mais difícil de ler. Aí vem o Java 13 com strings de várias linhas ! 💪
Se liga só !!
public class TesteCompile {
public static void main(String [] args) {
var s = """
{
"nome": "Sassine El-Asmar",
"idade": "23",
"stacks": ["backend", "frontend", "mobile"]
} """;
System.out.println(s);
}
}
Agora, executamos o método principal por meio de inicialização de arquivo único:
java --enable-preview --source 13 TesteCompile.java
{
"nome": "Sassine El-Asmar",
"idade": "23",
"stacks": ["backend", "frontend", "mobile"]
}
A String resultante se estende por várias linhas, as aspas "" são deixadas intactas e até as guias \t são preservadas!
Agora existem classes de dados em Java! Essas classes são declaradas com a palavra-chave record e têm Getters automáticos, um construtor e o método equals () etc. Você pode se livrar de um grande pedaço de código clichê! 🙌
jshell> record Pessoa(String nome, int idade) {}
| created record Pessoa
jshell> var x = new Employee("Sassine", 23);
x ==> Pessoa[nome=Sassine, idade=23]
jshell> x.name()
$2 ==> "Sassine"
Scala tem um recurso semelhante com classes de caso e Kotlin com classes de dados . Em Java, muitos desenvolvedores usaram o Lombok até agora, que oferecia praticamente os recursos que agora inspiravam o records Java 14. Mais detalhes podem ser encontrados neste artigo do Baeldung.
Primeiro verificamos se s é do tipo e String, em seguida, lançamos novamente para recuperar seu comprimento… né?
Não mais! agora, com o Java 14, o compilador é inteligente o suficiente para inferir o tipo automaticamente após a verificação de instância :
Object obj = new String("Oi");
if (obj instanceof String s) {
System.out.println("String length: " + s.length());
}
Com a palavra-chave sealed , você pode restringir quais classes podem estender uma determinada classe ou interface.
Aqui está um exemplo:
public sealed interface Fruit permits Apple, Pear {
String getName();
}
public final class Apple implements Fruit {
public String getName() { return "Apple"; }
}
public final class Pear implements Fruit {
public String getName() { return "Pear"; }
}
Então, como isso nos ajuda? Bem, agora você sabe quantos Fruits são. Este é realmente um passo importante na direção de correspondência de padrões totalmente suportada , onde você pode tratar as classes como enums.
Esse sealed recurso combina perfeitamente com a nova switch expressão explicada anteriormente.
Ou seja não precisa mais do ” –enable-preview ” para os itens listados acima .
A API de vetor fornece um mecanismo para os desenvolvedores tornarem explícito para o compilador que as operações de vetor devem ser usadas. No entanto, isso torna o código mais complicado. Primeiro, é necessário obter uma espécie de vetor.
static final VectorSpecies<Float> SPECIES = FloatVector.SPECIES_256;
void vectorComputation(float[] a, float[] b, float[] c) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
var m = SPECIES.indexInRange(i, a.length);
// FloatVector va, vb, vc;
var va = FloatVector.fromArray(SPECIES, a, i, m);
var vb = FloatVector.fromArray(SPECIES, b, i, m);
var vc = va.mul(va)
.add(vb.mul(vb))
.neg();
vc.intoArray(c, i, m);
}
}
Expanda a expressividade e a aplicabilidade das expressões switch, permitindo que os padrões apareçam nos rótulos de maiúsculas e minúsculas sem precisar de Instaceof.
Introduziu dois novos padrões: padrões protegidos e entre parênteses.
Implementação antes do JDK17:
public String getValue(Object o) {
String result = "";
if(o instanceof Integer i) {
result = "Integer %d".formatted(i);
} else if(o instanceof Double d) {
result = "Double %d".formatted(d);
} else if(o instanceof Long l) {
result = "Long %d".formatted(l);
} else if(o instanceof String s) {
result = "String %d".formatted(s);
}
return result;
}
Vamos refatorar esse método para a nova feature do JDK17:
public String getValue(Object o) {
return switch(o) {
case Integer i -> "Integer %d".formatted(i);
case Double d -> "Double %d".formatted(d);
case Long l -> "Long %d".formatted(l);
case String s -> "String %d".formatted(is);
default -> o.toString();
};
}
Dê uma olhada e um exemplo utilizando os novos padrões:
public void quantasPortasTem(Veiculo o) {
switch(o){
case Carro c && (c.getPortas == 2) ->
System.out.println("é um carro duas portas");
case Carro c && (c.getPortas == 4) ->
System.out.println("é um carro quatro portas");
default -> System.out.println("não é um carro.");
};
}
A codificação padrão atual pode ser lida em tempo de execução por meio Charset.defaultCharset()da propriedade do sistema "file.encoding". Desde o Java 17 , a propriedade do sistema "native.encoding" pode ser usada para ler a codificação, que – antes do Java 18 – seria a codificação padrão se nenhuma for especificada:
Sendo assim o file.encoding poderia vir como UTF-8 em alguns sistemas, Cp1252 ou default.
Antes:
Default charset : US-ASCII
file.encoding : default
native.encoding : UTF-8
Agora
Default charset : UTF-8
file.encoding : UTF-8
native.encoding : Cp1252
Agora no java 18 default não é mais reconhecido e por padrão "file.encoding" é UTF-8
No Linux e MacOS tanto o java 17 e 18 já resultam em todas as opções como UTF-8
Até agora, se quiséssemos integrar trechos de código de várias linhas ao JavaDoc, tínhamos que fazer isso de maneira bastante complicada via <'pre>…</pre'> e algumas regrinhas que tinhamos que seguir.
Agora com a tag @ snippet conseguimos exibir o trecho do código-fonte completo.
/**
* Escrevendo um arquivo:
*
* {@snippet :
* try (BufferedWriter writer = Files.newBufferedWriter(path)) {
* writer.write(text);
* }
* }
*/
Integrar trechos de outros arquivos
No FileWriter.java , marcaríamos o código da seguinte forma:
// @start region="writeFile"
try (BufferedWriter writer = Files.newBufferedWriter(path)) {
writer.write(text);
}
// @end
e utilizamos a referencia dele assim:
/**
* Escrevendo um arquivo:
*
* {@snippet file="FileWriter.java" region="writeFile"}
*/
Bom, listei as principais funções novas que tivemos entre as versões 8 a 18 😎 mas claro que existem muitas outras além de depreciações de lib;
Quiser saber mais acesse a documentação oficial da Oracle