Os fluxos Java 8 permitem que os desenvolvedores extraiam dados precisos de uma grande coleção, usando um conjunto de operações predefinidas.

Antes do lançamento do Java 8, o uso do termo "fluxo" em Java seria automaticamente associado ao I / O. No entanto, o Java 8 introduziu um fluxo que pode ser referido como um conjunto de etapas computacionais encadeadas no que é comumente referido como "pipeline de fluxo".

Este artigo irá apresentá-lo aos fluxos Java 8 e demonstrar como eles podem ser úteis em seus projetos.

O que é um fluxo?

Um fluxo é uma interface Java que obtém uma fonte, conduz um conjunto de operações para extrair dados específicos e, em seguida, fornece esses dados ao aplicativo para uso. Essencialmente, ele permite que você extraia dados especializados de uma coleção de dados generalizados.

Como funcionam os streams

Um pipeline de stream sempre começa com uma fonte. O tipo de fonte depende do tipo de dados com os quais você está lidando, mas dois dos mais populares são arrays e coleções.

instagram viewer

Para transformar a coleção em um fluxo inicial, você precisará adicionar o Stream() função para a fonte. Isso colocará a fonte no pipeline de fluxo, onde várias operações intermediárias diferentes (como filtro() e ordenar()) pode operar nele.

Depois que todas as operações intermediárias necessárias forem realizadas, você pode introduzir uma operação de terminal (como para cada()), que produzirá os dados previamente extraídos da fonte.

Vida sem córregos

O Java 8 foi lançado em 2014, mas antes disso, os desenvolvedores Java ainda precisavam extrair dados especializados de uma coleção de dados gerais.

Digamos que você tenha uma lista de caracteres aleatórios que são combinados com números aleatórios para formar valores de string exclusivos, mas você deseja apenas os valores que começam com o caractere “C” e deseja organizar o resultado em ordem crescente pedido. É assim que você extrai os dados sem fluxos.

Relacionado: O que você precisa saber sobre como usar strings em Java

Filtrando e classificando valores sem exemplo de fluxos


import java.util. ArrayList;
import java.util. Arrays;
import java.util. Lista;
public class Main {
public static void main (String [] args) {
// declara e inicializa a lista de array
Lista randomValues ​​= Arrays.asList (
"E11", "D12", "A13", "F14", "C15", "A16",
"B11", "B12", "C13", "B14", "B15", "B16",
"F12", "E13", "C11", "C14", "A15", "C16",
"F11", "C12", "D13", "E14", "D15", "D16"
);
// declara que a lista de array irá armazenar os valores necessários
Lista requiredValues ​​= new ArrayList <> ();
// extraindo os valores necessários e armazenando-os em reqquiredValues
randomValues.forEach (valor -> {
if (value.startsWith ("C")) {
requiredValues.add (valor);
}
});
// classificar os valores necessários em ordem crescente
requiredValues.sort ((String value1, String value2) -> value1.compareTo (value2));
// imprime cada valor no console
requiredValues.forEach ((String value) -> System.out.println (value));
}
}

Você também precisará declarar e inicializar a lista de matriz se estiver usando streams ou algum outro método de extração. O que você não precisaria fazer se estivesse usando streams é declarar uma nova variável para conter os valores necessários, nem criar as outras cinco linhas de código no exemplo acima.

Relacionado: Como criar e realizar operações em matrizes em Java

O código acima produz a seguinte saída no console:


C11
C12
C13
C14
C15
C16

Vida com córregos

Na programação, a eficiência fala em produzir o mesmo resultado com significativamente menos código. Isso é exatamente o que um pipeline de fluxo faz para um programador. Então, da próxima vez que alguém perguntar: "por que é importante usar streams em seu projeto?" Simplificando: “streams suportam programação eficiente”.

Continuando com nosso exemplo acima, é assim que a introdução de streams transforma todo o programa.

Filtrando e classificando valores com um exemplo de fluxo


import java.util. Arrays;
import java.util. Lista;
public class Main {
public static void main (String [] args) {
// declara e inicializa a lista de array
Lista randomValues ​​= Arrays.asList (
"E11", "D12", "A13", "F14", "C15", "A16",
"B11", "B12", "C13", "B14", "B15", "B16",
"F12", "E13", "C11", "C14", "A15", "C16",
"F11", "C12", "D13", "E14", "D15", "D16"
);
// recupera apenas os valores que começam com C, classifica-os e imprime-os no console.
randomValues.stream (). filter (value-> value.startsWith ("C")). Sorted (). forEach (System.out:: println);
}
}

O código acima demonstra o quão poderosa é a interface de fluxo. Ele pega uma lista de valores de matriz aleatória e a transforma em um fluxo usando o Stream() função. O fluxo é então reduzido a uma lista de matriz que contém os valores necessários (que são todos os valores que começam com C), usando o filtro() função.

Como você pode ver no exemplo acima, o C os valores são organizados aleatoriamente na lista da matriz. Se você fosse imprimir o fluxo neste ponto do pipeline, o valor C15 seria impresso primeiro. Portanto, o ordenar() A função é introduzida no pipeline de stream para reorganizar a nova matriz em ordem crescente.

A função final no pipeline do stream é um para cada() função. Esta é uma função de terminal usada para interromper o pipeline de stream e produz os seguintes resultados no console:


C11
C12
C13
C14
C15
C16

Há uma extensa lista de operações intermediárias que podem ser usadas em um pipeline de fluxo.

Um pipeline de stream sempre começa com uma única fonte e um Stream() função, e sempre termina com uma única operação de terminal (embora existam várias outras diferentes para escolha.) Mas entre essas duas seções está uma lista de seis operações intermediárias que você pode usar.

Em nosso exemplo acima, apenas duas dessas operações intermediárias são usadasfiltro() e ordenar(). A operação intermediária que você escolher dependerá das tarefas que deseja realizar.

Se qualquer um dos valores que começam com “C” em nossa lista de arrays acima estivesse em minúsculas e executássemos as mesmas operações intermediárias com eles, obteríamos o seguinte resultado.

Executando operações de filtro e classificação em valores minúsculos, exemplo


import java.util. Arrays;
import java.util. Lista;
public class Main {
public static void main (String [] args) {
// declara e inicializa a lista de array
Lista randomValues ​​= Arrays.asList (
"E11", "D12", "A13", "F14", "C15", "A16",
"B11", "B12", "c13", "B14", "B15", "B16",
"F12", "E13", "C11", "C14", "A15", "c16",
"F11", "C12", "D13", "E14", "D15", "D16"
);
// recupera apenas os valores que começam com C, classifica-os e imprime-os no console.
randomValues.stream (). filter (value-> value.startsWith ("C")). Sorted (). forEach (System.out:: println);
}
}

O código acima produzirá os seguintes valores no console:


C11
C12
C14
C15

O único problema com a saída acima é que ela não representa com precisão todos os valores em nossa lista de arrays. Uma boa maneira de corrigir esse pequeno erro é apresentar outra operação intermediária ao pipeline de fluxo; esta operação é conhecida como mapa() função.

Usando o Exemplo de Função de Mapa


import java.util. Arrays;
import java.util. Lista;
public class Main {
public static void main (String [] args) {
// declara e inicializa a lista de array
Lista randomValues ​​= Arrays.asList (
"E11", "D12", "A13", "F14", "C15", "A16",
"B11", "B12", "c13", "B14", "B15", "B16",
"F12", "E13", "C11", "C14", "A15", "c16",
"F11", "C12", "D13", "E14", "D15", "D16"
);
// transforma todos os caracteres minúsculos em maiúsculas,
// recupera apenas os valores que começam com C, classifica-os e imprime-os no console.
randomValues.stream (). map (String:: toUpperCase) .filter (value-> value.startsWith ("C")). Sorted (). forEach (System.out:: println);
}
}

O mapa() função transforma um objeto de um estado para outro; em nosso exemplo acima, ele transforma todos os caracteres minúsculos na lista de array em caracteres maiúsculos.

Colocando o mapa() funcionar um pouco antes do filtro() função recupera todos os valores que começam com C da lista de matrizes.

O código acima produz o seguinte resultado no console, representando com sucesso todos os valores na lista de matrizes.


C11
C12
C13
C14
C15
C16

As outras três operações intermediárias que você pode usar em seus aplicativos incluem:

  • olhadinha()
  • limite()
  • pular()

Java 8 Streams facilita a criação de código eficiente

Com os fluxos Java 8, você pode extrair dados adicionais específicos e relevantes de uma grande fonte com uma linha de código. Contanto que você inclua a inicial Stream() e um operador de terminal, você pode usar qualquer combinação de operações intermediárias que fornecem resultados adequados para o seu objetivo.

Se você está se perguntando sobre a linha de código incluída em nosso filtro() função; é conhecido como "expressão lambda". As expressões lambda são outro recurso introduzido com o Java 8 e contém muitos detalhes que podem ser úteis.

E-mail
Uma introdução rápida ao Java 8 Lambdas

Se você é um programador Java e está interessado em aprender mais sobre lambdas do Java 8, neste artigo vamos dar uma olhada mais de perto na sintaxe e no uso de lambda.

Leia a seguir

Tópicos relacionados
  • Programação
  • Java
  • Tutoriais de codificação
Sobre o autor
Kadeisha Kean (13 artigos publicados)

Kadeisha Kean é um desenvolvedor de software full-stack e redator técnico / tecnológico. Ela tem a habilidade distinta de simplificar alguns dos conceitos tecnológicos mais complexos; produzindo material que pode ser facilmente entendido por qualquer novato em tecnologia. Ela é apaixonada por escrever, desenvolver softwares interessantes e viajar pelo mundo (através de documentários).

Mais de Kadeisha Kean

Assine a nossa newsletter

Junte-se ao nosso boletim informativo para dicas de tecnologia, análises, e-books grátis e ofertas exclusivas!

Mais um passo…!

Confirme o seu endereço de e-mail no e-mail que acabamos de enviar.

.