Java fornece um novo pacote adicional em Java 8 chamado java.util.stream. Este pacote consiste em classes, interfaces e enum para permitir operações de estilo funcional nos elementos. Você pode usar o stream importando o pacote java.util.stream.
Stream oferece os seguintes recursos:
- Stream não armazena elementos. Ele simplesmente transmite elementos de uma fonte, como uma estrutura de dados, um array ou um canal de E/S, por meio de um pipeline de operações computacionais.
- Stream é de natureza funcional. As operações executadas em um fluxo não modificam sua origem. Por exemplo, filtrar um Stream obtido de uma coleção produz um novo Stream sem os elementos filtrados, em vez de remover elementos da coleção de origem.
- Stream é preguiçoso e avalia o código apenas quando necessário.
- Os elementos de um fluxo são visitados apenas uma vez durante a vida do fluxo. Assim como um Iterador, um novo fluxo deve ser gerado para revisitar os mesmos elementos da fonte.
Você pode usar stream para filtrar, coletar, imprimir e converter de uma estrutura de dados para outra, etc. Nos exemplos a seguir, aplicamos várias operações com a ajuda de stream.
Métodos de interface de fluxo Java
| Métodos | Descrição |
|---|---|
| boolean allMatch (predicado predicado) | Ele retorna todos os elementos deste fluxo que correspondem ao predicado fornecido. Se o fluxo estiver vazio, true será retornado e o predicado não será avaliado. |
| boolean anyMatch (predicado predicado) | Ele retorna qualquer elemento deste fluxo que corresponda ao predicado fornecido. Se o fluxo estiver vazio, false será retornado e o predicado não será avaliado. |
| Construtor estático Stream.Builder() | Ele retorna um construtor para um Stream. |
| R coletar(colecionador coletor) | Ele executa uma operação de redução mutável nos elementos deste fluxo usando um Coletor. Um Coletor encapsula as funções usadas como argumentos para coletar (Fornecedor, BiConsumer, BiConsumer), permitindo a reutilização de estratégias de coleta e composição de operações de coleta, como agrupamento ou particionamento em vários níveis. |
| R collect (fornecedor fornecedor, acumulador BiConsumer, combinador BiConsumer) | Ele executa uma operação de redução mutável nos elementos deste fluxo. Uma redução mutável é aquela em que o valor reduzido é um contêiner de resultado mutável, como um ArrayList, e os elementos são incorporados pela atualização do estado do resultado em vez de pela substituição do resultado. |
| concat de fluxo estático (fluxo a, fluxo b) | Ele cria um fluxo concatenado preguiçosamente cujos elementos são todos os elementos do primeiro fluxo seguidos por todos os elementos do segundo fluxo. O fluxo resultante será ordenado se ambos os fluxos de entrada estiverem ordenados e paralelo se algum dos fluxos de entrada for paralelo. Quando o fluxo resultante é fechado, os manipuladores de fechamento de ambos os fluxos de entrada são invocados. |
| contagem longa() | Ele retorna a contagem de elementos neste fluxo. Este é um caso especial de redução. |
| Fluxo distinto() | Ele retorna um fluxo que consiste em elementos distintos (de acordo com Object.equals(Object)) deste fluxo. |
| Fluxo estático vazio() | Ele retorna um Stream sequencial vazio. |
| Filtro de fluxo (predicado predicado) | Ele retorna um fluxo que consiste nos elementos desse fluxo que correspondem ao predicado fornecido. |
| Opcional findAny() | Ele retorna um Opcional descrevendo algum elemento do fluxo, ou um Opcional vazio se o fluxo estiver vazio. |
| Opcional encontrarPrimeiro() | Ele retorna um Opcional descrevendo o primeiro elemento deste fluxo, ou um Opcional vazio se o fluxo estiver vazio. Se o fluxo não tiver ordem de encontro, qualquer elemento poderá ser retornado. |
| Fluxo flatMap(Funçãomapeador) | Ele retorna um fluxo que consiste nos resultados da substituição de cada elemento deste fluxo pelo conteúdo de um fluxo mapeado produzido pela aplicação da função de mapeamento fornecida a cada elemento. Cada fluxo mapeado é fechado depois que seu conteúdo é colocado nesse fluxo. (Se um fluxo mapeado for nulo, um fluxo vazio será usado.) |
| DoubleStream flatMapToDouble (mapeador de função) | Ele retorna um DoubleStream que consiste nos resultados da substituição de cada elemento deste fluxo pelo conteúdo de um fluxo mapeado produzido pela aplicação da função de mapeamento fornecida a cada elemento. Cada fluxo mapeado é fechado depois que seu conteúdo é colocado nesse fluxo. (Se um fluxo mapeado for nulo, um fluxo vazio será usado.) |
| IntStream flatMapToInt (mapeador de função) | Ele retorna um IntStream que consiste nos resultados da substituição de cada elemento deste fluxo pelo conteúdo de um fluxo mapeado produzido pela aplicação da função de mapeamento fornecida a cada elemento. Cada fluxo mapeado é fechado depois que seu conteúdo é colocado nesse fluxo. (Se um fluxo mapeado for nulo, um fluxo vazio será usado.) |
| LongStream flatMapToLong (mapeador de função) | Ele retorna um LongStream que consiste nos resultados da substituição de cada elemento deste fluxo pelo conteúdo de um fluxo mapeado produzido pela aplicação da função de mapeamento fornecida a cada elemento. Cada fluxo mapeado é fechado depois que seu conteúdo é colocado nesse fluxo. (Se um fluxo mapeado for nulo, um fluxo vazio será usado.) |
| void forEach (ação do consumidor) | Ele executa uma ação para cada elemento deste fluxo. |
| void forEachOrdered(ação do consumidor) | Ele executa uma ação para cada elemento deste fluxo, na ordem de encontro do fluxo, se o fluxo tiver uma ordem de encontro definida. |
| Geração de fluxo estático (fornecedores) | Ele retorna um fluxo sequencial não ordenado infinito onde cada elemento é gerado pelo Fornecedor fornecido. Isto é adequado para gerar fluxos constantes, fluxos de elementos aleatórios, etc. |
| iteração de fluxo estático (semente T, UnaryOperator f) | Ele retorna um Stream ordenado sequencial infinito produzido pela aplicação iterativa de uma função f a um elemento inicial seed, produzindo um Stream que consiste em seed, f(seed), f(f(seed)), etc. |
| Limite de fluxo (maxSize longo) | Ele retorna um fluxo que consiste nos elementos desse fluxo, truncado para não ter mais que maxSize de comprimento. |
| Mapa de fluxo (mapeador de funções) | Ele retorna um fluxo que consiste nos resultados da aplicação de uma determinada função aos elementos deste fluxo. |
| DoubleStream mapToDouble (mapeador ToDoubleFunction) | Ele retorna um DoubleStream que consiste nos resultados da aplicação de uma determinada função aos elementos deste fluxo. |
| IntStream mapToInt (mapeador ToIntFunction) | Ele retorna um IntStream que consiste nos resultados da aplicação de uma determinada função aos elementos deste fluxo. | LongStream mapToLong (mapeador ToLongFunction) | Ele retorna um LongStream que consiste nos resultados da aplicação de uma determinada função aos elementos deste fluxo. |
| Máx opcional (comparador comparador) | Ele retorna o elemento máximo deste fluxo de acordo com o Comparador fornecido. Este é um caso especial de redução. |
| Min opcional (comparador comparador) | Ele retorna o elemento mínimo deste fluxo de acordo com o Comparador fornecido. Este é um caso especial de redução. |
| booleano noneMatch (predicado predicado) | Ele retorna elementos deste fluxo que correspondem ao predicado fornecido. Se o fluxo estiver vazio, true será retornado e o predicado não será avaliado. |
| Fluxo estático de @SafeVarargs de (T... valores) | Ele retorna um fluxo ordenado sequencial cujos elementos são os valores especificados. |
| Fluxo estático de (T t) | Ele retorna um Stream sequencial contendo um único elemento. |
| Espiada do stream (ação do consumidor) | Ele retorna um fluxo que consiste nos elementos desse fluxo, executando adicionalmente a ação fornecida em cada elemento à medida que os elementos são consumidos do fluxo resultante. |
| Redução opcional (acumulador BinaryOperator) | Ele realiza uma redução nos elementos deste fluxo, utilizando uma função de acumulação associativa, e retorna um Opcional descrevendo o valor reduzido, se houver. |
| T reduzir (identidade T, acumulador BinaryOperator) | Ele realiza uma redução nos elementos deste fluxo, utilizando o valor de identidade fornecido e uma função de acumulação associativa, e retorna o valor reduzido. |
| U reduz (identidade U, acumulador BiFunction, combinador BinaryOperator) | Ele realiza uma redução nos elementos deste fluxo, utilizando as funções de identidade, acumulação e combinação fornecidas. |
| Pular fluxo (n longo) | Ele retorna um fluxo que consiste nos elementos restantes deste fluxo após descartar os primeiros n elementos do fluxo. Se este fluxo contiver menos de n elementos, um fluxo vazio será retornado. |
| Fluxo classificado() | Ele retorna um fluxo que consiste nos elementos desse fluxo, classificados de acordo com a ordem natural. Se os elementos deste fluxo não forem Comparáveis, uma java.lang.ClassCastException poderá ser lançada quando a operação do terminal for executada. |
| Fluxo classificado (comparador comparador) | Ele retorna um fluxo que consiste nos elementos deste fluxo, classificados de acordo com o Comparador fornecido. |
| Objeto[] paraArray() | Ele retorna um array contendo os elementos deste fluxo. |
| A[] toArray(gerador IntFunction) | Ele retorna um array contendo os elementos deste fluxo, usando a função geradora fornecida para alocar o array retornado, bem como quaisquer arrays adicionais que possam ser necessários para uma execução particionada ou para redimensionamento. |
Exemplo Java: Filtrando coleção sem usar Stream
No exemplo a seguir, estamos filtrando dados sem usar stream. Essa abordagem é usada antes do lançamento do pacote stream.
javafx
import java.util.*; class Product{ int id; String name; float price; public Product(int id, String name, float price) { this.id = id; this.name = name; this.price = price; } } public class JavaStreamExample { public static void main(String[] args) { List productsList = new ArrayList(); //Adding Products productsList.add(new Product(1,'HP Laptop',25000f)); productsList.add(new Product(2,'Dell Laptop',30000f)); productsList.add(new Product(3,'Lenevo Laptop',28000f)); productsList.add(new Product(4,'Sony Laptop',28000f)); productsList.add(new Product(5,'Apple Laptop',90000f)); List productPriceList = new ArrayList(); for(Product product: productsList){ // filtering data of list if(product.price<30000){ productpricelist.add(product.price); adding price to a productpricelist } system.out.println(productpricelist); displaying data < pre> <p> <strong>Output:</strong> </p> <pre> [25000.0, 28000.0, 28000.0] </pre> <hr> <h3>Java Stream Example: Filtering Collection by using Stream</h3> <p>Here, we are filtering data by using stream. You can see that code is optimized and maintained. Stream provides fast execution.</p> <pre> import java.util.*; import java.util.stream.Collectors; class Product{ int id; String name; float price; public Product(int id, String name, float price) { this.id = id; this.name = name; this.price = price; } } public class JavaStreamExample { public static void main(String[] args) { List productsList = new ArrayList(); //Adding Products productsList.add(new Product(1,'HP Laptop',25000f)); productsList.add(new Product(2,'Dell Laptop',30000f)); productsList.add(new Product(3,'Lenevo Laptop',28000f)); productsList.add(new Product(4,'Sony Laptop',28000f)); productsList.add(new Product(5,'Apple Laptop',90000f)); List productPriceList2 =productsList.stream() .filter(p -> p.price > 30000)// filtering data .map(p->p.price) // fetching price .collect(Collectors.toList()); // collecting as list System.out.println(productPriceList2); } } </pre> <p> <strong>Output:</strong> </p> <pre> [90000.0] </pre> <hr> <h3>Java Stream Iterating Example</h3> <p>You can use stream to iterate any number of times. Stream provides predefined methods to deal with the logic you implement. In the following example, we are iterating, filtering and passed a limit to fix the iteration.</p> <pre> import java.util.stream.*; public class JavaStreamExample { public static void main(String[] args){ Stream.iterate(1, element->element+1) .filter(element->element%5==0) .limit(5) .forEach(System.out::println); } } </pre> <p> <strong>Output:</strong> </p> <pre> 5 10 15 20 25 </pre> <hr> <h3>Java Stream Example: Filtering and Iterating Collection</h3> <p>In the following example, we are using filter() method. Here, you can see code is optimized and very concise.</p> <pre> import java.util.*; class Product{ int id; String name; float price; public Product(int id, String name, float price) { this.id = id; this.name = name; this.price = price; } } public class JavaStreamExample { public static void main(String[] args) { List productsList = new ArrayList(); //Adding Products productsList.add(new Product(1,'HP Laptop',25000f)); productsList.add(new Product(2,'Dell Laptop',30000f)); productsList.add(new Product(3,'Lenevo Laptop',28000f)); productsList.add(new Product(4,'Sony Laptop',28000f)); productsList.add(new Product(5,'Apple Laptop',90000f)); // This is more compact approach for filtering data productsList.stream() .filter(product -> product.price == 30000) .forEach(product -> System.out.println(product.name)); } } </pre> <p> <strong>Output:</strong> </p> <pre> Dell Laptop </pre> <hr> <h3>Java Stream Example : reduce() Method in Collection</h3> <p>This method takes a sequence of input elements and combines them into a single summary result by repeated operation. For example, finding the sum of numbers, or accumulating elements into a list. </p> <p>In the following example, we are using reduce() method, which is used to sum of all the product prices.</p> <pre> import java.util.*; class Product{ int id; String name; float price; public Product(int id, String name, float price) { this.id = id; this.name = name; this.price = price; } } public class JavaStreamExample { public static void main(String[] args) { List productsList = new ArrayList(); //Adding Products productsList.add(new Product(1,'HP Laptop',25000f)); productsList.add(new Product(2,'Dell Laptop',30000f)); productsList.add(new Product(3,'Lenevo Laptop',28000f)); productsList.add(new Product(4,'Sony Laptop',28000f)); productsList.add(new Product(5,'Apple Laptop',90000f)); // This is more compact approach for filtering data Float totalPrice = productsList.stream() .map(product->product.price) .reduce(0.0f,(sum, price)->sum+price); // accumulating price System.out.println(totalPrice); // More precise code float totalPrice2 = productsList.stream() .map(product->product.price) .reduce(0.0f,Float::sum); // accumulating price, by referring method of Float class System.out.println(totalPrice2); } } </pre> <p> <strong>Output:</strong> </p> <pre> 201000.0 201000.0 </pre> <hr> <h3>Java Stream Example: Sum by using Collectors Methods</h3> <p>We can also use collectors to compute sum of numeric values. In the following example, we are using Collectors class and it?s specified methods to compute sum of all the product prices.</p> <pre> import java.util.*; import java.util.stream.Collectors; class Product{ int id; String name; float price; public Product(int id, String name, float price) { this.id = id; this.name = name; this.price = price; } } public class JavaStreamExample { public static void main(String[] args) { List productsList = new ArrayList(); //Adding Products productsList.add(new Product(1,'HP Laptop',25000f)); productsList.add(new Product(2,'Dell Laptop',30000f)); productsList.add(new Product(3,'Lenevo Laptop',28000f)); productsList.add(new Product(4,'Sony Laptop',28000f)); productsList.add(new Product(5,'Apple Laptop',90000f)); // Using Collectors's method to sum the prices. double totalPrice3 = productsList.stream() .collect(Collectors.summingDouble(product->product.price)); System.out.println(totalPrice3); } } </pre> <p> <strong>Output:</strong> </p> <pre> 201000.0 </pre> <hr> <h3>Java Stream Example: Find Max and Min Product Price</h3> <p>Following example finds min and max product price by using stream. It provides convenient way to find values without using imperative approach.</p> <pre> import java.util.*; class Product{ int id; String name; float price; public Product(int id, String name, float price) { this.id = id; this.name = name; this.price = price; } } public class JavaStreamExample { public static void main(String[] args) { List productsList = new ArrayList(); //Adding Products productsList.add(new Product(1,'HP Laptop',25000f)); productsList.add(new Product(2,'Dell Laptop',30000f)); productsList.add(new Product(3,'Lenevo Laptop',28000f)); productsList.add(new Product(4,'Sony Laptop',28000f)); productsList.add(new Product(5,'Apple Laptop',90000f)); // max() method to get max Product price Product productA = productsList.stream().max((product1, product2)->product1.price > product2.price ? 1: -1).get(); System.out.println(productA.price); // min() method to get min Product price Product productB = productsList.stream().min((product1, product2)->product1.price > product2.price ? 1: -1).get(); System.out.println(productB.price); } } </pre> <p> <strong>Output:</strong> </p> <pre> 90000.0 25000.0 </pre> <hr> <h3>Java Stream Example: count() Method in Collection</h3> <pre> import java.util.*; class Product{ int id; String name; float price; public Product(int id, String name, float price) { this.id = id; this.name = name; this.price = price; } } public class JavaStreamExample { public static void main(String[] args) { List productsList = new ArrayList(); //Adding Products productsList.add(new Product(1,'HP Laptop',25000f)); productsList.add(new Product(2,'Dell Laptop',30000f)); productsList.add(new Product(3,'Lenevo Laptop',28000f)); productsList.add(new Product(4,'Sony Laptop',28000f)); productsList.add(new Product(5,'Apple Laptop',90000f)); // count number of products based on the filter long count = productsList.stream() .filter(product->product.price<30000) .count(); system.out.println(count); } < pre> <p> <strong>Output:</strong> </p> <pre> 3 </pre> <p>stream allows you to collect your result in any various forms. You can get you result as set, list or map and can perform manipulation on the elements.</p> <hr> <h3>Java Stream Example : Convert List into Set</h3> <pre> import java.util.*; import java.util.stream.Collectors; class Product{ int id; String name; float price; public Product(int id, String name, float price) { this.id = id; this.name = name; this.price = price; } } public class JavaStreamExample { public static void main(String[] args) { List productsList = new ArrayList(); //Adding Products productsList.add(new Product(1,'HP Laptop',25000f)); productsList.add(new Product(2,'Dell Laptop',30000f)); productsList.add(new Product(3,'Lenevo Laptop',28000f)); productsList.add(new Product(4,'Sony Laptop',28000f)); productsList.add(new Product(5,'Apple Laptop',90000f)); // Converting product List into Set Set productPriceList = productsList.stream() .filter(product->product.price product.price) .collect(Collectors.toSet()); // collect it as Set(remove duplicate elements) System.out.println(productPriceList); } } </pre> <p> <strong>Output:</strong> </p> <pre> [25000.0, 28000.0] </pre> <hr> <h3>Java Stream Example : Convert List into Map</h3> <pre> import java.util.*; import java.util.stream.Collectors; class Product{ int id; String name; float price; public Product(int id, String name, float price) { this.id = id; this.name = name; this.price = price; } } public class JavaStreamExample { public static void main(String[] args) { List productsList = new ArrayList(); //Adding Products productsList.add(new Product(1,'HP Laptop',25000f)); productsList.add(new Product(2,'Dell Laptop',30000f)); productsList.add(new Product(3,'Lenevo Laptop',28000f)); productsList.add(new Product(4,'Sony Laptop',28000f)); productsList.add(new Product(5,'Apple Laptop',90000f)); // Converting Product List into a Map Map productPriceMap = productsList.stream() .collect(Collectors.toMap(p->p.id, p->p.name)); System.out.println(productPriceMap); } } </pre> <p> <strong>Output:</strong> </p> <pre> {1=HP Laptop, 2=Dell Laptop, 3=Lenevo Laptop, 4=Sony Laptop, 5=Apple Laptop} </pre> <hr> <h3>Method Reference in stream</h3> <pre> import java.util.*; import java.util.stream.Collectors; class Product{ int id; String name; float price; public Product(int id, String name, float price) { this.id = id; this.name = name; this.price = price; } public int getId() { return id; } public String getName() { return name; } public float getPrice() { return price; } } public class JavaStreamExample { public static void main(String[] args) { List productsList = new ArrayList(); //Adding Products productsList.add(new Product(1,'HP Laptop',25000f)); productsList.add(new Product(2,'Dell Laptop',30000f)); productsList.add(new Product(3,'Lenevo Laptop',28000f)); productsList.add(new Product(4,'Sony Laptop',28000f)); productsList.add(new Product(5,'Apple Laptop',90000f)); List productPriceList = productsList.stream() .filter(p -> p.price > 30000) // filtering data .map(Product::getPrice) // fetching price by referring getPrice method .collect(Collectors.toList()); // collecting as list System.out.println(productPriceList); } } </pre> <p> <strong>Output:</strong> </p> <pre> [90000.0] </pre> <hr></30000)></pre></30000){> Exemplo de Java Stream: Filtrando coleção usando Stream
Aqui, estamos filtrando dados usando stream. Você pode ver que o código é otimizado e mantido. Stream fornece execução rápida.
import java.util.*; import java.util.stream.Collectors; class Product{ int id; String name; float price; public Product(int id, String name, float price) { this.id = id; this.name = name; this.price = price; } } public class JavaStreamExample { public static void main(String[] args) { List productsList = new ArrayList(); //Adding Products productsList.add(new Product(1,'HP Laptop',25000f)); productsList.add(new Product(2,'Dell Laptop',30000f)); productsList.add(new Product(3,'Lenevo Laptop',28000f)); productsList.add(new Product(4,'Sony Laptop',28000f)); productsList.add(new Product(5,'Apple Laptop',90000f)); List productPriceList2 =productsList.stream() .filter(p -> p.price > 30000)// filtering data .map(p->p.price) // fetching price .collect(Collectors.toList()); // collecting as list System.out.println(productPriceList2); } } Saída:
[90000.0]
Exemplo de iteração de fluxo Java
Você pode usar stream para iterar quantas vezes quiser. Stream fornece métodos predefinidos para lidar com a lógica que você implementa. No exemplo a seguir, estamos iterando, filtrando e ultrapassando um limite para corrigir a iteração.
import java.util.stream.*; public class JavaStreamExample { public static void main(String[] args){ Stream.iterate(1, element->element+1) .filter(element->element%5==0) .limit(5) .forEach(System.out::println); } } Saída:
5 10 15 20 25
Exemplo de fluxo Java: filtragem e iteração de coleção
No exemplo a seguir, estamos usando o método filter(). Aqui você pode ver que o código está otimizado e muito conciso.
import java.util.*; class Product{ int id; String name; float price; public Product(int id, String name, float price) { this.id = id; this.name = name; this.price = price; } } public class JavaStreamExample { public static void main(String[] args) { List productsList = new ArrayList(); //Adding Products productsList.add(new Product(1,'HP Laptop',25000f)); productsList.add(new Product(2,'Dell Laptop',30000f)); productsList.add(new Product(3,'Lenevo Laptop',28000f)); productsList.add(new Product(4,'Sony Laptop',28000f)); productsList.add(new Product(5,'Apple Laptop',90000f)); // This is more compact approach for filtering data productsList.stream() .filter(product -> product.price == 30000) .forEach(product -> System.out.println(product.name)); } } Saída:
Dell Laptop
Exemplo de fluxo Java: método reduz() na coleção
Este método pega uma sequência de elementos de entrada e os combina em um único resultado resumido por operação repetida. Por exemplo, encontrar a soma dos números ou acumular elementos em uma lista.
No exemplo a seguir, estamos usando o método reduz(), que é usado para somar todos os preços dos produtos.
import java.util.*; class Product{ int id; String name; float price; public Product(int id, String name, float price) { this.id = id; this.name = name; this.price = price; } } public class JavaStreamExample { public static void main(String[] args) { List productsList = new ArrayList(); //Adding Products productsList.add(new Product(1,'HP Laptop',25000f)); productsList.add(new Product(2,'Dell Laptop',30000f)); productsList.add(new Product(3,'Lenevo Laptop',28000f)); productsList.add(new Product(4,'Sony Laptop',28000f)); productsList.add(new Product(5,'Apple Laptop',90000f)); // This is more compact approach for filtering data Float totalPrice = productsList.stream() .map(product->product.price) .reduce(0.0f,(sum, price)->sum+price); // accumulating price System.out.println(totalPrice); // More precise code float totalPrice2 = productsList.stream() .map(product->product.price) .reduce(0.0f,Float::sum); // accumulating price, by referring method of Float class System.out.println(totalPrice2); } } Saída:
201000.0 201000.0
Exemplo de fluxo Java: soma usando métodos de coletores
Também podemos usar coletores para calcular a soma de valores numéricos. No exemplo a seguir, estamos usando a classe Collectors e seus métodos especificados para calcular a soma de todos os preços dos produtos.
import java.util.*; import java.util.stream.Collectors; class Product{ int id; String name; float price; public Product(int id, String name, float price) { this.id = id; this.name = name; this.price = price; } } public class JavaStreamExample { public static void main(String[] args) { List productsList = new ArrayList(); //Adding Products productsList.add(new Product(1,'HP Laptop',25000f)); productsList.add(new Product(2,'Dell Laptop',30000f)); productsList.add(new Product(3,'Lenevo Laptop',28000f)); productsList.add(new Product(4,'Sony Laptop',28000f)); productsList.add(new Product(5,'Apple Laptop',90000f)); // Using Collectors's method to sum the prices. double totalPrice3 = productsList.stream() .collect(Collectors.summingDouble(product->product.price)); System.out.println(totalPrice3); } } Saída:
201000.0
Exemplo de Java Stream: Encontre o preço máximo e mínimo do produto
O exemplo a seguir encontra o preço mínimo e máximo do produto usando stream. Ele fornece uma maneira conveniente de encontrar valores sem usar a abordagem imperativa.
import java.util.*; class Product{ int id; String name; float price; public Product(int id, String name, float price) { this.id = id; this.name = name; this.price = price; } } public class JavaStreamExample { public static void main(String[] args) { List productsList = new ArrayList(); //Adding Products productsList.add(new Product(1,'HP Laptop',25000f)); productsList.add(new Product(2,'Dell Laptop',30000f)); productsList.add(new Product(3,'Lenevo Laptop',28000f)); productsList.add(new Product(4,'Sony Laptop',28000f)); productsList.add(new Product(5,'Apple Laptop',90000f)); // max() method to get max Product price Product productA = productsList.stream().max((product1, product2)->product1.price > product2.price ? 1: -1).get(); System.out.println(productA.price); // min() method to get min Product price Product productB = productsList.stream().min((product1, product2)->product1.price > product2.price ? 1: -1).get(); System.out.println(productB.price); } } Saída:
90000.0 25000.0
Exemplo de Java Stream: método count() na coleção
import java.util.*; class Product{ int id; String name; float price; public Product(int id, String name, float price) { this.id = id; this.name = name; this.price = price; } } public class JavaStreamExample { public static void main(String[] args) { List productsList = new ArrayList(); //Adding Products productsList.add(new Product(1,'HP Laptop',25000f)); productsList.add(new Product(2,'Dell Laptop',30000f)); productsList.add(new Product(3,'Lenevo Laptop',28000f)); productsList.add(new Product(4,'Sony Laptop',28000f)); productsList.add(new Product(5,'Apple Laptop',90000f)); // count number of products based on the filter long count = productsList.stream() .filter(product->product.price<30000) .count(); system.out.println(count); } < pre> <p> <strong>Output:</strong> </p> <pre> 3 </pre> <p>stream allows you to collect your result in any various forms. You can get you result as set, list or map and can perform manipulation on the elements.</p> <hr> <h3>Java Stream Example : Convert List into Set</h3> <pre> import java.util.*; import java.util.stream.Collectors; class Product{ int id; String name; float price; public Product(int id, String name, float price) { this.id = id; this.name = name; this.price = price; } } public class JavaStreamExample { public static void main(String[] args) { List productsList = new ArrayList(); //Adding Products productsList.add(new Product(1,'HP Laptop',25000f)); productsList.add(new Product(2,'Dell Laptop',30000f)); productsList.add(new Product(3,'Lenevo Laptop',28000f)); productsList.add(new Product(4,'Sony Laptop',28000f)); productsList.add(new Product(5,'Apple Laptop',90000f)); // Converting product List into Set Set productPriceList = productsList.stream() .filter(product->product.price product.price) .collect(Collectors.toSet()); // collect it as Set(remove duplicate elements) System.out.println(productPriceList); } } </pre> <p> <strong>Output:</strong> </p> <pre> [25000.0, 28000.0] </pre> <hr> <h3>Java Stream Example : Convert List into Map</h3> <pre> import java.util.*; import java.util.stream.Collectors; class Product{ int id; String name; float price; public Product(int id, String name, float price) { this.id = id; this.name = name; this.price = price; } } public class JavaStreamExample { public static void main(String[] args) { List productsList = new ArrayList(); //Adding Products productsList.add(new Product(1,'HP Laptop',25000f)); productsList.add(new Product(2,'Dell Laptop',30000f)); productsList.add(new Product(3,'Lenevo Laptop',28000f)); productsList.add(new Product(4,'Sony Laptop',28000f)); productsList.add(new Product(5,'Apple Laptop',90000f)); // Converting Product List into a Map Map productPriceMap = productsList.stream() .collect(Collectors.toMap(p->p.id, p->p.name)); System.out.println(productPriceMap); } } </pre> <p> <strong>Output:</strong> </p> <pre> {1=HP Laptop, 2=Dell Laptop, 3=Lenevo Laptop, 4=Sony Laptop, 5=Apple Laptop} </pre> <hr> <h3>Method Reference in stream</h3> <pre> import java.util.*; import java.util.stream.Collectors; class Product{ int id; String name; float price; public Product(int id, String name, float price) { this.id = id; this.name = name; this.price = price; } public int getId() { return id; } public String getName() { return name; } public float getPrice() { return price; } } public class JavaStreamExample { public static void main(String[] args) { List productsList = new ArrayList(); //Adding Products productsList.add(new Product(1,'HP Laptop',25000f)); productsList.add(new Product(2,'Dell Laptop',30000f)); productsList.add(new Product(3,'Lenevo Laptop',28000f)); productsList.add(new Product(4,'Sony Laptop',28000f)); productsList.add(new Product(5,'Apple Laptop',90000f)); List productPriceList = productsList.stream() .filter(p -> p.price > 30000) // filtering data .map(Product::getPrice) // fetching price by referring getPrice method .collect(Collectors.toList()); // collecting as list System.out.println(productPriceList); } } </pre> <p> <strong>Output:</strong> </p> <pre> [90000.0] </pre> <hr></30000)> stream permite que você colete seu resultado em várias formas. Você pode obter o resultado como conjunto, lista ou mapa e realizar manipulação dos elementos.
Exemplo de fluxo Java: converter lista em conjunto
import java.util.*; import java.util.stream.Collectors; class Product{ int id; String name; float price; public Product(int id, String name, float price) { this.id = id; this.name = name; this.price = price; } } public class JavaStreamExample { public static void main(String[] args) { List productsList = new ArrayList(); //Adding Products productsList.add(new Product(1,'HP Laptop',25000f)); productsList.add(new Product(2,'Dell Laptop',30000f)); productsList.add(new Product(3,'Lenevo Laptop',28000f)); productsList.add(new Product(4,'Sony Laptop',28000f)); productsList.add(new Product(5,'Apple Laptop',90000f)); // Converting product List into Set Set productPriceList = productsList.stream() .filter(product->product.price product.price) .collect(Collectors.toSet()); // collect it as Set(remove duplicate elements) System.out.println(productPriceList); } } Saída:
[25000.0, 28000.0]
Exemplo de fluxo Java: converter lista em mapa
import java.util.*; import java.util.stream.Collectors; class Product{ int id; String name; float price; public Product(int id, String name, float price) { this.id = id; this.name = name; this.price = price; } } public class JavaStreamExample { public static void main(String[] args) { List productsList = new ArrayList(); //Adding Products productsList.add(new Product(1,'HP Laptop',25000f)); productsList.add(new Product(2,'Dell Laptop',30000f)); productsList.add(new Product(3,'Lenevo Laptop',28000f)); productsList.add(new Product(4,'Sony Laptop',28000f)); productsList.add(new Product(5,'Apple Laptop',90000f)); // Converting Product List into a Map Map productPriceMap = productsList.stream() .collect(Collectors.toMap(p->p.id, p->p.name)); System.out.println(productPriceMap); } } Saída:
{1=HP Laptop, 2=Dell Laptop, 3=Lenevo Laptop, 4=Sony Laptop, 5=Apple Laptop} Referência de método no stream
import java.util.*; import java.util.stream.Collectors; class Product{ int id; String name; float price; public Product(int id, String name, float price) { this.id = id; this.name = name; this.price = price; } public int getId() { return id; } public String getName() { return name; } public float getPrice() { return price; } } public class JavaStreamExample { public static void main(String[] args) { List productsList = new ArrayList(); //Adding Products productsList.add(new Product(1,'HP Laptop',25000f)); productsList.add(new Product(2,'Dell Laptop',30000f)); productsList.add(new Product(3,'Lenevo Laptop',28000f)); productsList.add(new Product(4,'Sony Laptop',28000f)); productsList.add(new Product(5,'Apple Laptop',90000f)); List productPriceList = productsList.stream() .filter(p -> p.price > 30000) // filtering data .map(Product::getPrice) // fetching price by referring getPrice method .collect(Collectors.toList()); // collecting as list System.out.println(productPriceList); } } Saída:
[90000.0]