A programação funcional é uma abordagem amplamente utilizada no desenvolvimento de software moderno. Java, sendo uma linguagem que suporta programação funcional e orientada a objetos, introduziu streams e lambdas em sua 8ª versão. Esses recursos permitem que os desenvolvedores apliquem um estilo funcional às coleções, tornando as operações nas coleções mais eficientes e limpas.

Streams em Java
Streams em Java transformam uma coleção em um fluxo de elementos. Eles permitem que os desenvolvedores executem operações funcionais em coleções, como mapeamento, filtragem e redução. Os fluxos são mais usados ​​para operações que envolvem transformação, agregação ou filtragem de dados.

Um exemplo de uso de streams é classificar uma lista de nomes em ordem alfabética. Podemos criar uma lista de nomes e então usar streams para classificá-los conforme mostrado abaixo:

List nomes = Arrays.asList("John", "Mary", "David", "Emily", "Tom");
nomes.stream().sorted().forEach(System.out::println); //saída: David, Emily, John, Mary, Tom

Aqui, criamos um stream usando o método stream() da lista. Em seguida, aplicamos o método sorted() para classificar os elementos no fluxo em ordem natural. Finalmente, o método forEach() é usado para imprimir cada elemento no stream.

Lambdas em Java
Lambdas são usados ​​para definir funções de primeira classe em Java. Essas funções podem consumir elementos de um fluxo e realizar operações neles. Lambdas são definidos fora de uma classe e podem ser passados ​​como argumentos para funções.

Para usar lambdas com streams, precisamos entender o conceito de interfaces funcionais. Estas são interfaces que possuem apenas um método abstrato. Expressões lambda podem ser usadas para fornecer uma implementação concreta para o método abstrato de uma interface funcional.

Classifique uma lista de nomes usando lambdas
Com base no exemplo acima, vamos classificar os nomes em ordem decrescente usando lambdas.

List nomes = Arrays.asList("John", "Mary", "David", "Emily", "Tom");
nomes.stream().sorted((a, b) -> b.compareTo(a)).forEach(System.out::println)); //saída: Tom, Mary, John, Emily, David

Aqui, usamos uma expressão lambda como argumento para o método sorted(). Esta função lambda aceita dois argumentos (aeb) e os compara, retornando um valor positivo, negativo ou zero com base na comparação. Isso nos permite classificar os elementos em ordem decrescente usando o método compareTo() nos elementos.

Transformar um stream novamente em uma coleção
Em alguns casos, podemos querer transformar um fluxo novamente em uma coleção após realizar operações nele. Podemos fazer isso usando o método collect(), que recebe um objeto Collector como argumento.

List nomes filtrados = nomes.stream()
.filter(name -> name.length() > 4) //mantém apenas nomes com comprimento > 4
.collect(Collectors.toList()); //retorna uma lista de nomes filtrados

O método collect() pega uma interface funcional do tipo Collector e a utiliza para acumular elementos em uma coleção. No exemplo acima, usamos o método toList() da classe Collectors para criar uma lista de nomes filtrados.

Outras operações em streams
Além de classificação e filtragem, existem outras operações que podem ser executadas em fluxos, como mapeamento, redução e iteração. Essas operações nos permitem transformar, reduzir e iterar sobre os elementos em um fluxo, respectivamente.

Mapear e reduzir um fluxo de números
Digamos que temos uma lista de números e queremos encontrar a soma de todos os números pares. Podemos fazer isso usando os métodos map() e reduz().

Lista números = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
int soma = números.stream()
.filter(num -> num % 2 == 0) //filtra números ímpares
.map(num -> num * 2) //dobra os números pares
.reduzir(0, (a, b) -> a b); //somar todos os números

Aqui, usamos o método map() para dobrar os números pares no fluxo e, em seguida, usamos o método reduzir() para somar todos os números. O resultado é uma soma de todos os números pares da lista.

Reutilizar operações em streams
Em alguns casos, poderemos precisar usar a mesma operação funcional em múltiplos fluxos. Para evitar escrever o mesmo código repetidamente, podemos criar uma interface funcional e passá-la como argumento para os métodos.

Vejamos o exemplo de classificação de uma lista de nomes pelo sobrenome. Podemos criar uma classe comparadora que implemente a interface Comparator e passá-la como argumento para o método sorted().

classe estática LastNameComparator implementa Comparator {
@Substituir
public int comparar(String nome1, String nome2) {
String[] partes1 = nome1.split(" ");
String últimoNome1 = partes1[partes1.comprimento - 1];
String[] partes2 = nome2.split(" ");
String últimoNome2 = partes2[parts2.length - 1];
retornar últimoNome2.compareTo(sobrenome1);
}
}

nomes.stream().sorted(new LastNameComparator()).forEach(System.out::println); //saída: Emily, David, John, Mary, Tom

Aqui, passamos o LastNameComparator como argumento para o método sorted() para classificar os nomes pelo sobrenome.

Conclusão
Streams e lambdas em Java fornecem uma maneira poderosa e eficiente de realizar operações funcionais em coleções. Eles permitem que os desenvolvedores escrevam códigos limpos, concisos e reutilizáveis. Ao compreender os conceitos de streams e lambdas, podemos melhorar nossas habilidades gerais de codificação e escrever códigos mais eficientes.

Um método eficaz para melhorar suas habilidades em Java é obter a certificação Java mais recente e usar os testes práticos 1Z0-830 disponíveis no MyExamCloud.