Java udostępnia nowy, dodatkowy pakiet w Javie 8 o nazwie java.util.stream. Pakiet ten składa się z klas, interfejsów i wyliczeń, które umożliwiają operacje na elementach w stylu funkcjonalnym. Możesz użyć strumienia, importując pakiet java.util.stream.
Strumień zapewnia następujące funkcje:
- Strumień nie przechowuje elementów. Po prostu przekazuje elementy ze źródła, takiego jak struktura danych, tablica lub kanał we/wy, poprzez potok operacji obliczeniowych.
- Strumień ma charakter funkcjonalny. Operacje wykonywane na strumieniu nie modyfikują jego źródła. Na przykład filtrowanie strumienia uzyskanego z kolekcji powoduje utworzenie nowego strumienia bez filtrowanych elementów, zamiast usuwania elementów z kolekcji źródłowej.
- Strumień jest leniwy i ocenia kod tylko wtedy, gdy jest to wymagane.
- Elementy strumienia są odwiedzane tylko raz w ciągu życia strumienia. Podobnie jak w przypadku Iteratora, należy wygenerować nowy strumień, aby ponownie odwiedzić te same elementy źródła.
Możesz użyć strumienia do filtrowania, gromadzenia, drukowania i konwertowania z jednej struktury danych na inną itp. W poniższych przykładach zastosowaliśmy różne operacje za pomocą strumienia.
Metody interfejsu strumienia Java
| Metody | Opis |
|---|---|
| wartość logiczna allMatch (predykat predykatu) | Zwraca wszystkie elementy tego strumienia, które pasują do podanego predykatu. Jeśli strumień jest pusty, zwracana jest wartość true, a predykat nie jest oceniany. |
| wartość logiczna anyMatch (predykat predykatu) | Zwraca dowolny element tego strumienia, który pasuje do podanego predykatu. Jeśli strumień jest pusty, zwracana jest wartość false, a predykat nie jest oceniany. |
| statyczny strumień.Builder builder() | Zwraca konstruktora dla strumienia. |
| R zbieraj (kolekcjoner) | Wykonuje zmienną operację redukcji elementów tego strumienia za pomocą kolektora. Kolekcjoner hermetyzuje funkcje używane jako argumenty do zbierania (Dostawca, BiConsumer, BiConsumer), umożliwiając ponowne wykorzystanie strategii zbierania i kompozycję operacji zbierania, takich jak grupowanie wielopoziomowe lub partycjonowanie. |
| R zbieraj (dostawca, akumulator BiConsumer, sumator BiConsumer) | Wykonuje zmienną operację redukcji na elementach tego strumienia. Zmienna redukcja to taka, w której zmniejszona wartość jest modyfikowalnym kontenerem wyników, takim jak ArrayList, a elementy są włączane poprzez aktualizację stanu wyniku, a nie przez zastąpienie wyniku. |
| statyczne połączenie strumienia (strumień a, strumień b) | Tworzy leniwie połączony strumień, którego elementami są wszystkie elementy pierwszego strumienia, po których następują wszystkie elementy drugiego strumienia. Wynikowy strumień jest uporządkowany, jeśli oba strumienie wejściowe są uporządkowane, i równoległy, jeśli którykolwiek ze strumieni wejściowych jest równoległy. Gdy wynikowy strumień zostanie zamknięty, wywoływane są procedury obsługi zamknięcia dla obu strumieni wejściowych. |
| długie liczenie() | Zwraca liczbę elementów w tym strumieniu. Jest to szczególny przypadek redukcji. |
| Strumień odrębny() | Zwraca strumień składający się z odrębnych elementów (zgodnie z Object.equals(Object)) tego strumienia. |
| statyczny strumień pusty() | Zwraca pusty sekwencyjny strumień. |
| Filtr strumienia (predykat predykatu) | Zwraca strumień składający się z elementów tego strumienia pasujących do podanego predykatu. |
| Opcjonalne findAny() | Zwraca opcję Option opisującą jakiś element strumienia lub pustą opcję Option, jeśli strumień jest pusty. |
| Opcjonalna funkcja findFirst() | Zwraca opcję opcjonalną opisującą pierwszy element tego strumienia lub pustą opcję opcjonalną, jeśli strumień jest pusty. Jeżeli w strumieniu nie ma kolejności spotkań, wówczas dowolny element może zostać zwrócony. |
| Strumień flatMap (funkcjatwórca map) | Zwraca strumień składający się z wyników zastąpienia każdego elementu tego strumienia zawartością zmapowanego strumienia utworzonego poprzez zastosowanie dostarczonej funkcji mapującej do każdego elementu. Każdy zmapowany strumień jest zamykany po umieszczeniu jego zawartości w tym strumieniu. (Jeśli zamapowany strumień ma wartość null, zamiast tego używany jest pusty strumień.) |
| DoubleStream flatMapToDouble (mapowanie funkcji) | Zwraca obiekt DoubleStream składający się z wyników zastąpienia każdego elementu tego strumienia zawartością zmapowanego strumienia utworzonego przez zastosowanie dostarczonej funkcji mapowania do każdego elementu. Każdy zmapowany strumień jest zamykany po umieszczeniu jego zawartości w tym strumieniu. (Jeśli zamapowany strumień ma wartość null, zamiast tego używany jest pusty strumień.) |
| IntStream flatMapToInt (mapowanie funkcji) | Zwraca IntStream składający się z wyników zastąpienia każdego elementu tego strumienia zawartością zmapowanego strumienia utworzonego przez zastosowanie dostarczonej funkcji mapującej do każdego elementu. Każdy zmapowany strumień jest zamykany po umieszczeniu jego zawartości w tym strumieniu. (Jeśli zamapowany strumień ma wartość null, zamiast tego używany jest pusty strumień.) |
| LongStream flatMapToLong (mapowanie funkcji) | Zwraca LongStream składający się z wyników zastąpienia każdego elementu tego strumienia zawartością zmapowanego strumienia utworzonego przez zastosowanie dostarczonej funkcji mapującej do każdego elementu. Każdy zmapowany strumień jest zamykany po umieszczeniu jego zawartości w tym strumieniu. (Jeśli zamapowany strumień ma wartość null, zamiast tego używany jest pusty strumień.) |
| void forEach (działanie konsumenckie) | Wykonuje akcję dla każdego elementu tego strumienia. |
| void forEachOrdered (działanie konsumenckie) | Wykonuje akcję dla każdego elementu tego strumienia, w kolejności spotkań strumienia, jeśli strumień ma zdefiniowaną kolejność spotkań. |
| statyczne generowanie strumienia (dostawcy) | Zwraca nieskończony, sekwencyjny nieuporządkowany strumień, w którym każdy element jest generowany przez dostarczonego Dostawcę. Jest to odpowiednie do generowania strumieni stałych, strumieni elementów losowych itp. |
| statyczna iteracja strumienia (ziarno T, UnaryOperator f) | Zwraca nieskończony, uporządkowany strumień utworzony przez iteracyjne zastosowanie funkcji f do początkowego elementu początkowego, tworząc strumień składający się z materiału siewnego, f(nasiono), f(f(nasiono)) itp. |
| Limit strumienia (długi maxSize) | Zwraca strumień składający się z elementów tego strumienia, obcięty tak, aby jego długość nie przekraczała maxSize. |
| Mapa strumienia (mapa funkcji) | Zwraca strumień składający się z wyników zastosowania danej funkcji do elementów tego strumienia. |
| DoubleStream mapToDouble(mapowanie funkcji ToDouble) | Zwraca DoubleStream składający się z wyników zastosowania danej funkcji do elementów tego strumienia. |
| IntStream mapToInt(mapowanie ToIntFunction) | Zwraca IntStream składający się z wyników zastosowania danej funkcji do elementów tego strumienia. | Mapa LongStreamToLong(mapa funkcji ToLong) | Zwraca LongStream składający się z wyników zastosowania danej funkcji do elementów tego strumienia. |
| Opcjonalnie max (komparator komparatora) | Zwraca maksymalny element tego strumienia zgodnie z dostarczonym komparatorem. Jest to szczególny przypadek redukcji. |
| Opcjonalnie min (komparator komparatora) | Zwraca minimalny element tego strumienia zgodnie z dostarczonym komparatorem. Jest to szczególny przypadek redukcji. |
| wartość logiczna noneMatch (predykat predykatu) | Zwraca elementy tego strumienia pasujące do podanego predykatu. Jeśli strumień jest pusty, zwracana jest wartość true, a predykat nie jest oceniany. |
| @SafeVarargs statyczny strumień (wartości T...) | Zwraca sekwencyjny uporządkowany strumień, którego elementy mają określone wartości. |
| statyczny strumień (T t) | Zwraca sekwencyjny Stream zawierający pojedynczy element. |
| Podgląd strumienia (działanie konsumenckie) | Zwraca strumień składający się z elementów tego strumienia, dodatkowo wykonując podaną akcję na każdym elemencie w miarę zużywania elementów z wynikowego strumienia. |
| Opcjonalna redukcja (akumulator BinaryOperator) | Dokonuje redukcji elementów tego strumienia, korzystając z funkcji akumulacji skojarzeniowej, i zwraca opcję Opcjonalną opisującą zmniejszoną wartość, jeśli taka istnieje. |
| T redukcja (tożsamość T, akumulator BinaryOperator) | Dokonuje redukcji elementów tego strumienia, wykorzystując podaną wartość tożsamości i funkcję akumulacji asocjacyjnej, i zwraca zredukowaną wartość. |
| Redukcja U (tożsamość U, akumulator BiFunction, sumator BinaryOperator) | Dokonuje redukcji elementów tego strumienia, korzystając z nadanych funkcji tożsamości, akumulacji i łączenia. |
| Pomiń strumień (długie n) | Zwraca strumień składający się z pozostałych elementów tego strumienia po odrzuceniu pierwszych n elementów strumienia. Jeśli ten strumień zawiera mniej niż n elementów, zostanie zwrócony pusty strumień. |
| Strumień posortowany() | Zwraca strumień składający się z elementów tego strumienia, posortowanych według naturalnego porządku. Jeśli elementy tego strumienia nie są porównywalne, podczas wykonywania operacji terminalowej może zostać zgłoszony wyjątek java.lang.ClassCastException. |
| Posortowany strumień (komparator komparatora) | Zwraca strumień składający się z elementów tego strumienia, posortowanych według dostarczonego komparatora. |
| Obiekt[] do tablicy() | Zwraca tablicę zawierającą elementy tego strumienia. |
| A[] toArray(generator funkcji Int) | Zwraca tablicę zawierającą elementy tego strumienia, korzystając z dostarczonej funkcji generatora w celu alokacji zwróconej tablicy, a także wszelkich dodatkowych tablic, które mogą być wymagane do wykonania partycjonowanego lub zmiany rozmiaru. |
Przykład Java: filtrowanie kolekcji bez użycia strumienia
W poniższym przykładzie filtrujemy dane bez użycia strumienia. Takie podejście stosowaliśmy przed wydaniem pakietu strumieniowego.
przekonwertuj int na ciąg c++
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){> Przykład strumienia Java: filtrowanie kolekcji przy użyciu strumienia
Tutaj filtrujemy dane za pomocą strumienia. Widać, że kod jest zoptymalizowany i utrzymywany. Strumień zapewnia szybką realizację.
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); } } Wyjście:
[90000.0]
Przykład iteracji strumienia Java
Możesz użyć strumienia do iteracji dowolną liczbę razy. Stream zapewnia predefiniowane metody radzenia sobie z implementowaną logiką. W poniższym przykładzie iterujemy, filtrujemy i przekraczamy limit, aby naprawić iterację.
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); } } Wyjście:
5 10 15 20 25
Przykład strumienia Java: filtrowanie i iterowanie kolekcji
W poniższym przykładzie używamy metody filter(). Tutaj widać, że kod jest zoptymalizowany i bardzo zwięzły.
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)); } } Wyjście:
Dell Laptop
Przykład strumienia Java: metoda redukcji() w kolekcji
Ta metoda pobiera sekwencję elementów wejściowych i łączy je w jeden wynik podsumowujący poprzez powtarzaną operację. Na przykład znalezienie sumy liczb lub zgromadzenie elementów na liście.
W poniższym przykładzie używamy metody redukcji(), która służy do sumowania cen wszystkich produktów.
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); } } Wyjście:
201000.0 201000.0
Przykład strumienia Java: Suma przy użyciu metod zbierających
Kolektorów możemy także używać do obliczania sumy wartości liczbowych. W poniższym przykładzie używamy klasy Collectors i jej określonych metod do obliczenia sumy cen wszystkich produktów.
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); } } Wyjście:
201000.0
Przykład strumienia Java: znajdź maksymalną i minimalną cenę produktu
Poniższy przykład pozwala znaleźć minimalną i maksymalną cenę produktu za pomocą strumienia. Zapewnia wygodny sposób znajdowania wartości bez stosowania podejścia imperatywnego.
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); } } Wyjście:
90000.0 25000.0
Przykład strumienia Java: metoda count() w kolekcji
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 pozwala na gromadzenie wyniku w dowolnej formie. Możesz uzyskać wynik w postaci zestawu, listy lub mapy i możesz manipulować elementami.
Przykład strumienia Java: Konwertuj listę na zestaw
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); } } Wyjście:
[25000.0, 28000.0]
Przykład strumienia Java: Konwertuj listę na mapę
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); } } Wyjście:
{1=HP Laptop, 2=Dell Laptop, 3=Lenevo Laptop, 4=Sony Laptop, 5=Apple Laptop} Odniesienie do metody w strumieniu
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); } } Wyjście:
[90000.0]