Operações intermediárias e finais

As streams são uma nova forma de trabalhar com coleções de dados no Java, introduzidas a partir do Java 8. Elas permitem realizar operações de forma mais eficiente e concisa, utilizando uma abordagem funcional.

Uma stream é uma sequência de elementos que pode ser processada em paralelo ou em série. Ela pode ser criada a partir de uma coleção, um array, um arquivo, entre outros. A partir daí, podemos realizar diversas operações nessa stream, como filtrar, mapear, ordenar, entre outras.

As operações intermediárias são aquelas que podem ser aplicadas em uma stream e retornam uma nova stream como resultado. Essas operações não são executadas imediatamente, mas apenas quando uma operação final é chamada.

Vamos ver alguns exemplos de operações intermediárias:

• Filter: permite filtrar os elementos da stream com base em uma condição. Por exemplo, podemos filtrar uma lista de números para retornar apenas os números pares.

                      List<Integer> numeros = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
  
                      List<Integer> numerosPares = numeros.stream()
                                                      .filter(n -> n % 2 == 0)
                                                      .collect(Collectors.toList());
  
                      System.out.println(numerosPares); // Output: [2, 4, 6, 8, 10]
                  

• Map: permite transformar cada elemento da stream em outro tipo de dado. Por exemplo, podemos transformar uma lista de strings em uma lista de seus respectivos tamanhos.

                      List<String> palavras = Arrays.asList("Java", "Stream", "Operações", "Intermediárias");
  
                      List<String> tamanhos = palavras.stream()
                                                      .map(s -> s.length())
                                                      .collect(Collectors.toList());
  
                      System.out.println(tamanhos); // Output: [4, 6, 11, 14]
                  

  As operações finais são aquelas que encerram a stream e retornam um resultado concreto. Algumas operações finais comuns são o forEach, collect e count.

Vamos ver alguns exemplos de operações finais:

• ForEach: permite executar uma ação em cada elemento da stream. Por exemplo, podemos imprimir cada elemento da lista.

                      List<String> nomes = Arrays.asList("João", "Maria", "Pedro", "Ana");
  
                      nomes.stream()
                          .forEach(nome -> System.out.println("Olá, " + nome + "!"));
  
                      // Output:
                      // Olá, João!
                      // Olá, Maria!
                      // Olá, Pedro!
                      // Olá, Ana!
                  

• Collect: permite coletar os elementos da stream em uma coleção ou em outro tipo de dado. Por exemplo, podemos coletar os números pares em um conjunto.

                      List<Integer> numeros = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
  
                      Set<Integer> numerosPares = numeros.stream()
                                                      .filter(n -> n % 2 == 0)
                                                      .collect(Collectors.toSet());
  
                      System.out.println(numerosPares); // Output: [2, 4, 6, 8, 10]
                  

Por fim, As streams e suas operações intermediárias e finais são uma forma poderosa de manipular coleções de dados no Java de maneira mais eficiente e concisa. Elas permitem escrever código mais legível e expressivo, facilitando o processamento e a transformação de dados.

Além das operações intermediárias e finais mencionadas, existem muitas outras disponíveis, como distinct (que remove elementos duplicados), limit (que limita o número de elementos da stream), skip (que pula os primeiros elementos da stream), reduce (que combina os elementos da stream em um único resultado) e muitas outras.

Streams no Java são uma poderosa ferramenta para manipulação de coleções de dados. As operações intermediárias permitem filtrar, mapear e ordenar os elementos da stream, enquanto as operações finais encerram a stream e retornam um resultado concreto. Combinando essas operações, podemos realizar transformações e ações de forma concisa e eficiente.