TRANSMITIR EM JAVA

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.

Sintaxe

Fluxo fluxo;

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:

Operações Intermediárias
Operações de Terminal

Operações Intermediárias

Operações de fluxo Java

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:

Fluxo mapa (Função mapeador)

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

Sintaxe:

Fluxo filtro(Predicado predicado)

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

Sintaxe:

Fluxo classificado()
Fluxo classificado(Comparador comparador)

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

Sintaxe:

Fluxo flatMap(Função > mapeador)

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

Sintaxe:

Fluxo distinto()

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:

Fluxo espiar(Consumidor Ação)

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

Java

    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  );      }   }

Saída

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.

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(Coletor coletor)

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

Sintaxe:

void forEach(Consumidor Açã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 BinaryOperator acumulador)
Opcional reduzir(BinaryOperator acumulador)

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

Sintaxe:

contagem longa()

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

Sintaxe:

Opcional encontrarPrimeiro()

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

Sintaxe:

boolean allMatch(Predicado predicado)

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

Sintaxe:

Booleano Anymatch (Predicado predicado)

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:

Java

    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:

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.