O fluxo foi introduzido em Java 8 a API Stream é usada para processar coleções de objetos. Um fluxo em Java é uma sequência de objetos que suporta vários métodos que podem ser canalizados para produzir o resultado desejado. 

Uso de Stream em Java

Os usos do Stream em Java são mencionados abaixo:

• Stream API é uma forma de expressar e processar coleções de objetos.
• Permita-nos realizar operações como filtragem, redução de mapeamento e classificação.

Como criar um fluxo Java

A criação do Java Stream é uma das etapas mais básicas antes de considerar as funcionalidades do Java Stream. Abaixo está a sintaxe fornecida para declarar um Java Stream.

classe de scanner java

Sintaxe

Fluxofluxo;

Aqui T é um objeto de classe ou tipo de dados dependendo da declaração.

Recursos de fluxo Java

Os recursos dos fluxos Java são mencionados abaixo:

• Um Stream não é uma estrutura de dados; ele apenas recebe informações de Collections Arrays ou canais de E/S.
• Os fluxos não modificam os dados originais; eles apenas produzem resultados usando seus métodos.
• Operações intermediárias (como mapa de filtros etc.) são preguiçosas e retornam outro Stream para que você possa encadeá-las.
• Uma operação de terminal (como collect forEach count) encerra o fluxo e fornece o resultado final.

Diferentes operações em streams

Existem dois tipos de operações em Streams:

1. Operações Intermediárias
2. Operações de Terminal

Operações Intermediárias

Operações intermediárias são os tipos de operações nas quais vários métodos são encadeados em uma linha.

Características das Operações Intermediárias

• Os métodos são encadeados.
• As operações intermediárias transformam um fluxo em outro fluxo.
• Ele permite o conceito de filtragem onde um método filtra os dados e os passa para outro método após o processamento.

Operações Intermediárias Importantes

Existem algumas operações intermediárias mencionadas abaixo:

1. mapa() : O método map é usado para retornar um fluxo que consiste nos resultados da aplicação de uma determinada função aos elementos deste fluxo.

Sintaxe:

Fluxomapa (Funçãomapeador)

2. filtro() : O método filter é usado para selecionar elementos de acordo com o Predicado passado como argumento.

Sintaxe:

Fluxofiltro(Predicadopredicado)

3. classificado() : O método classificado é usado para classificar o fluxo.

Sintaxe:

Fluxoclassificado()
Fluxoclassificado(Comparadorcomparador)

4. flatMap(): A operação flatMap em Java Streams é usada para nivelar um fluxo de coleções em um único fluxo de elementos.

Sintaxe:

FluxoflatMap(Função> mapeador)

5. distinto() : Remove elementos duplicados. Ele retorna um fluxo que consiste em elementos distintos (de acordo com Object.equals(Object)).

Sintaxe:

Fluxodistinto()

6. espiar() : executa uma ação em cada elemento sem modificar o fluxo. Ele retorna um fluxo que consiste nos elementos deste fluxo, executando adicionalmente a ação fornecida em cada elemento à medida que os elementos são consumidos do fluxo resultante.

Sintaxe:

Fluxoespiar(ConsumidorAção)

Programa Java que demonstra o uso de todas as operações intermediárias:

import java.util.Arrays; import java.util.HashSet; import java.util.List; import java.util.Set; import java.util.stream.Collectors; public class StreamIntermediateOperationsExample {  public static void main(String[] args) {  // List of lists of names  List<List<String>> listOfLists = Arrays.asList(  Arrays.asList('Reflection' 'Collection' 'Stream')  Arrays.asList('Structure' 'State' 'Flow')  Arrays.asList('Sorting' 'Mapping' 'Reduction' 'Stream')  );  // Create a set to hold intermediate results  Set<String> intermediateResults = new HashSet<>();  // Stream pipeline demonstrating various intermediate operations  List<String> result = listOfLists.stream()  .flatMap(List::stream)   .filter(s -> s.startsWith('S'))   .map(String::toUpperCase)   .distinct()   .sorted()   .peek(s -> intermediateResults.add(s))  .collect(Collectors.toList());   // Print the intermediate results  System.out.println('Intermediate Results:');  intermediateResults.forEach(System.out::println);  // Print the final result  System.out.println('Final Result:');  result.forEach(System.out::println);  } } 

Intermediate Results: STRUCTURE STREAM STATE SORTING Final Result: SORTING STATE STREAM STRUCTURE 

Explicação:

• O listOfLists é criado como uma lista contendo outras listas de strings.
• flatMap(Lista::stream): Achata as listas aninhadas em um único fluxo de strings.
• filtro(s -> s.startsWith('S')) : filtra as strings para incluir apenas aquelas que começam com 'S'.
• mapa(String::toUpperCase) : converte cada string no fluxo em letras maiúsculas.
• distinto() : remove quaisquer strings duplicadas.
• classificado() : classifica as strings resultantes em ordem alfabética.
• espiar(...): Adiciona cada elemento processado ao conjunto intermediaResults para inspeção intermediária.
• coletar(Collectors.toList()): Coleta as strings finais processadas em uma lista chamada resultado.

O programa imprime os resultados intermediários armazenados no conjunto intermediaResults. Finalmente, ele imprime a lista de resultados que contém as strings totalmente processadas após todas as operações de stream.

Operações de Terminal

Operações de Terminal são o tipo de Operações que retornam o resultado. Essas operações não são processadas posteriormente, apenas retornam um valor de resultado final.

string substitui tudo java

Operações importantes do terminal

1. coletar() : o método collect é usado para retornar o resultado das operações intermediárias realizadas no stream.

Sintaxe:

R coletar(Coletorcoletor)

2. forEach() : o método forEach é usado para iterar cada elemento do fluxo.

Sintaxe:

void forEach(ConsumidorAção)

3. reduzir(): O método reduzir é usado para reduzir os elementos de um fluxo a um único valor. O método reduzir usa um BinaryOperator como parâmetro.

Sintaxe:

T reduzir(T identidade BinaryOperatoracumulador)
Opcionalreduzir(BinaryOperatoracumulador)

4. contagem() : Retorna a contagem de elementos no fluxo.

Sintaxe:

contagem longa()

5. encontrarPrimeiro() : Retorna o primeiro elemento do fluxo, se presente.

Sintaxe:

OpcionalencontrarPrimeiro()

vlc para baixar o youtube

6. allMatch() : verifica se todos os elementos do fluxo correspondem a um determinado predicado.

Sintaxe:

boolean allMatch(Predicadopredicado)

7. Qualquer correspondência () : verifica se algum elemento do fluxo corresponde a um determinado predicado.

Sintaxe:

Booleano Anymatch (Predicadopredicado)

Aqui, uma variável recebe 0 como valor inicial e i é adicionado a ela.

Observação: As operações intermediárias são executadas com base no conceito de avaliação preguiçosa, que garante que cada método retorne um valor fixo (operação de terminal) antes de passar para o próximo método.

Programa Java usando todas as operações de terminal:

import java.util.*; import java.util.stream.Collectors; public class StreamTerminalOperationsExample {  public static void main(String[] args) {  // Sample data  List<String> names = Arrays.asList(  'Reflection' 'Collection' 'Stream'  'Structure' 'Sorting' 'State'  );  // forEach: Print each name  System.out.println('forEach:');  names.stream().forEach(System.out::println);  // collect: Collect names starting with 'S' into a list  List<String> sNames = names.stream()  .filter(name -> name.startsWith('S'))  .collect(Collectors.toList());  System.out.println('ncollect (names starting with 'S'):');  sNames.forEach(System.out::println);  // reduce: Concatenate all names into a single string  String concatenatedNames = names.stream().reduce(  ''  (partialString element) -> partialString + ' ' + element  );  System.out.println('nreduce (concatenated names):');  System.out.println(concatenatedNames.trim());  // count: Count the number of names  long count = names.stream().count();  System.out.println('ncount:');  System.out.println(count);  // findFirst: Find the first name  Optional<String> firstName = names.stream().findFirst();  System.out.println('nfindFirst:');  firstName.ifPresent(System.out::println);  // allMatch: Check if all names start with 'S'  boolean allStartWithS = names.stream().allMatch(  name -> name.startsWith('S')  );  System.out.println('nallMatch (all start with 'S'):');  System.out.println(allStartWithS);  // anyMatch: Check if any name starts with 'S'  boolean anyStartWithS = names.stream().anyMatch(  name -> name.startsWith('S')  );  System.out.println('nanyMatch (any start with 'S'):');  System.out.println(anyStartWithS);  } } 

Saída:

Explicação:

• A lista de nomes é criada com strings de amostra.
• para cada: Imprime cada nome na lista.
• coletar : filtra nomes que começam com 'S' e os coleta em uma nova lista.
• reduzir : concatena todos os nomes em uma única string.
• contar : conta o número total de nomes.
• encontrar primeiro : Encontra e imprime o primeiro nome na lista.
• todas as partidas : verifica se todos os nomes começam com 'S'.
• azarado : Verifica se algum nome começa com 'S'.

O programa imprime cada nome, nomes começando com 'S', nomes concatenados, a contagem de nomes, o primeiro nome, se todos os nomes começam com 'S' e se algum nome começa com 'S'.

Benefício do Java Stream

Existem alguns benefícios pelos quais usamos Stream em Java, conforme mencionado abaixo:

• Sem armazenamento
• Pipeline de funções
• Preguiça
• Pode ser infinito
• Pode ser paralelizado
• Pode ser criado a partir de coleções, arrays, arquivos, linhas, métodos em Stream IntStream etc.

Casos de uso reais de fluxos Java

Streams são amplamente usados ​​em aplicativos Java modernos para:

• Processamento de Dados
• Para processar respostas JSON/XML
• Para operações de banco de dados
• Processamento Simultâneo