Java fournit un nouveau package supplémentaire dans Java 8 appelé java.util.stream. Ce package se compose de classes, d'interfaces et d'énumérations pour permettre des opérations de style fonctionnel sur les éléments. Vous pouvez utiliser le flux en important le package java.util.stream.
Stream offre les fonctionnalités suivantes :
- Stream ne stocke pas d'éléments. Il transmet simplement des éléments d'une source telle qu'une structure de données, un tableau ou un canal d'E/S, via un pipeline d'opérations de calcul.
- Stream est de nature fonctionnelle. Les opérations effectuées sur un flux ne modifient pas sa source. Par exemple, filtrer un Stream obtenu à partir d'une collection produit un nouveau Stream sans les éléments filtrés, plutôt que de supprimer des éléments de la collection source.
- Stream est paresseux et évalue le code uniquement lorsque cela est nécessaire.
- Les éléments d'un flux ne sont visités qu'une seule fois au cours de la vie d'un flux. Comme un Iterator, un nouveau flux doit être généré pour revisiter les mêmes éléments de la source.
Vous pouvez utiliser stream pour filtrer, collecter, imprimer et convertir d'une structure de données à une autre, etc. Dans les exemples suivants, nous avons appliqué diverses opérations à l'aide de stream.
Méthodes d'interface de flux Java
| Méthodes | Description |
|---|---|
| boolean allMatch(Prédicat prédicat) | Il renvoie tous les éléments de ce flux qui correspondent au prédicat fourni. Si le flux est vide, true est renvoyé et le prédicat n'est pas évalué. |
| boolean anyMatch(Prédicat prédicat) | Il renvoie tout élément de ce flux qui correspond au prédicat fourni. Si le flux est vide, false est renvoyé et le prédicat n'est pas évalué. |
| constructeur statique Stream.Builder() | Il renvoie un constructeur pour un Stream. |
| R collect(Collecteur collecteur) | Il effectue une opération de réduction mutable sur les éléments de ce flux à l'aide d'un Collector. Un collecteur encapsule les fonctions utilisées comme arguments pour collecter (Supplier, BiConsumer, BiConsumer), permettant la réutilisation des stratégies de collecte et la composition des opérations de collecte telles que le regroupement ou le partitionnement à plusieurs niveaux. |
| R collect (Fournisseur fournisseur, accumulateur BiConsumer, combinateur BiConsumer) | Il effectue une opération de réduction mutable sur les éléments de ce flux. Une réduction mutable est une réduction dans laquelle la valeur réduite est un conteneur de résultat mutable, tel qu'un ArrayList, et les éléments sont incorporés en mettant à jour l'état du résultat plutôt qu'en remplaçant le résultat. |
| concat de flux statique (flux a, flux b) | Il crée un flux concaténé paresseusement dont les éléments sont tous les éléments du premier flux suivis de tous les éléments du deuxième flux. Le flux résultant est ordonné si les deux flux d’entrée sont ordonnés, et parallèle si l’un des flux d’entrée est parallèle. Lorsque le flux résultant est fermé, les gestionnaires de fermeture des deux flux d'entrée sont appelés. |
| compte long() | Il renvoie le nombre d'éléments dans ce flux. Il s’agit d’un cas particulier de réduction. |
| Flux distinct() | Il renvoie un flux constitué des éléments distincts (selon Object.equals(Object)) de ce flux. |
| Flux statique vide() | Il renvoie un Stream séquentiel vide. |
| Filtre de flux (Prédicat Prédicat) | Il renvoie un flux composé des éléments de ce flux qui correspondent au prédicat donné. |
| FindAny() facultatif | Il renvoie un facultatif décrivant un élément du flux, ou un facultatif vide si le flux est vide. |
| FindFirst() facultatif | Il renvoie un facultatif décrivant le premier élément de ce flux, ou un facultatif vide si le flux est vide. Si le flux n'a pas d'ordre de rencontre, alors n'importe quel élément peut être renvoyé. |
| Flux flatMap(Fonctionmappeur) | Il renvoie un flux constitué des résultats du remplacement de chaque élément de ce flux par le contenu d'un flux mappé produit en appliquant la fonction de mappage fournie à chaque élément. Chaque flux mappé est fermé une fois son contenu placé dans ce flux. (Si un flux mappé est nul, un flux vide est utilisé à la place.) |
| DoubleStream flatMapToDouble (Mappeur de fonctions) | Il renvoie un DoubleStream composé des résultats du remplacement de chaque élément de ce flux par le contenu d'un flux mappé produit en appliquant la fonction de mappage fournie à chaque élément. Chaque flux mappé est fermé une fois son contenu placé dans ce flux. (Si un flux mappé est nul, un flux vide est utilisé à la place.) |
| IntStream flatMapToInt (Mappeur de fonctions) | Il renvoie un IntStream composé des résultats du remplacement de chaque élément de ce flux par le contenu d'un flux mappé produit en appliquant la fonction de mappage fournie à chaque élément. Chaque flux mappé est fermé une fois son contenu placé dans ce flux. (Si un flux mappé est nul, un flux vide est utilisé à la place.) |
| LongStream flatMapToLong (Mappeur de fonctions) | Il renvoie un LongStream composé des résultats du remplacement de chaque élément de ce flux par le contenu d'un flux mappé produit en appliquant la fonction de mappage fournie à chaque élément. Chaque flux mappé est fermé une fois son contenu placé dans ce flux. (Si un flux mappé est nul, un flux vide est utilisé à la place.) |
| void forEach (action du consommateur) | Il effectue une action pour chaque élément de ce flux. |
| void forEachOrdered (action du consommateur) | Il effectue une action pour chaque élément de ce flux, dans l'ordre de rencontre du flux si le flux a un ordre de rencontre défini. |
| Génération de flux statique (fournisseurs) | Il renvoie un flux non ordonné séquentiel infini où chaque élément est généré par le fournisseur fourni. Ceci convient pour générer des flux constants, des flux d’éléments aléatoires, etc. |
| itération de flux statique (graine T, UnaryOperator f) | Il renvoie un Stream ordonné séquentiellement infini produit par l'application itérative d'une fonction f à une graine d'élément initial, produisant un Stream composé de graine, f(seed), f(f(seed)), etc. |
| Limite de flux (long maxSize) | Il renvoie un flux composé des éléments de ce flux, tronqué pour ne pas dépasser maxSize en longueur. |
| Carte de flux (mappeur de fonctions) | Il renvoie un flux constitué des résultats de l'application de la fonction donnée aux éléments de ce flux. |
| DoubleStream mapToDouble (mappeur ToDoubleFunction) | Il renvoie un DoubleStream composé des résultats de l'application de la fonction donnée aux éléments de ce flux. |
| IntStream mapToInt (mappeur ToIntFunction) | Il renvoie un IntStream composé des résultats de l'application de la fonction donnée aux éléments de ce flux. | LongStream mapToLong (mappeur ToLongFunction) | Il renvoie un LongStream composé des résultats de l'application de la fonction donnée aux éléments de ce flux. |
| Max en option (comparateur comparateur) | Il renvoie l'élément maximum de ce flux selon le comparateur fourni. Il s’agit d’un cas particulier de réduction. |
| Min en option (comparateur comparateur) | Il renvoie l'élément minimum de ce flux selon le comparateur fourni. Il s’agit d’un cas particulier de réduction. |
| booléen noneMatch(Prédicat prédicat) | Il renvoie les éléments de ce flux correspondant au prédicat fourni. Si le flux est vide, true est renvoyé et le prédicat n'est pas évalué. |
| @SafeVarargs Flux statique de (valeurs T...) | Il renvoie un flux ordonné séquentiel dont les éléments sont les valeurs spécifiées. |
| Flux statique de (T t) | Il renvoie un Stream séquentiel contenant un seul élément. |
| Aperçu du flux (action du consommateur) | Il renvoie un flux composé des éléments de ce flux, en effectuant en outre l'action fournie sur chaque élément au fur et à mesure que les éléments sont consommés à partir du flux résultant. |
| Réduction facultative (accumulateur BinaryOperator) | Il effectue une réduction sur les éléments de ce flux, à l'aide d'une fonction d'accumulation associative, et renvoie un facultatif décrivant la valeur réduite, le cas échéant. |
| T réduire (T identité, accumulateur BinaryOperator) | Il effectue une réduction sur les éléments de ce flux, en utilisant la valeur d'identité fournie et une fonction d'accumulation associative, et renvoie la valeur réduite. |
| U réduire (identité U, accumulateur BiFunction, combinateur BinaryOperator) | Il effectue une réduction sur les éléments de ce flux, en utilisant les fonctions d'identité, d'accumulation et de combinaison fournies. |
| Saut de flux (long n) | Il renvoie un flux composé des éléments restants de ce flux après avoir supprimé les n premiers éléments du flux. Si ce flux contient moins de n éléments, un flux vide sera renvoyé. |
| Flux trié() | Il renvoie un flux constitué des éléments de ce flux, triés selon l'ordre naturel. Si les éléments de ce flux ne sont pas comparables, une java.lang.ClassCastException peut être levée lors de l'exécution de l'opération du terminal. |
| Flux trié (Comparateur comparateur) | Il renvoie un flux constitué des éléments de ce flux, triés selon le Comparator fourni. |
| Objet[] versArray() | Il renvoie un tableau contenant les éléments de ce flux. |
| A[] toArray (générateur IntFunction) | Il renvoie un tableau contenant les éléments de ce flux, en utilisant la fonction génératrice fournie pour allouer le tableau renvoyé, ainsi que tous les tableaux supplémentaires qui pourraient être requis pour une exécution partitionnée ou pour un redimensionnement. |
Exemple Java : filtrage d'une collection sans utiliser Stream
Dans l'exemple suivant, nous filtrons les données sans utiliser de flux. Cette approche est utilisée avant la publication du package stream.
coupe de chaîne javascript
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){> Exemple de flux Java : filtrage d'une collection à l'aide de Stream
Ici, nous filtrons les données en utilisant stream. Vous pouvez voir que le code est optimisé et maintenu. Stream permet une exécution rapide.
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); } } Sortir:
[90000.0]
Exemple d'itération de flux Java
Vous pouvez utiliser stream pour effectuer une itération autant de fois que vous le souhaitez. Stream fournit des méthodes prédéfinies pour gérer la logique que vous implémentez. Dans l'exemple suivant, nous itérons, filtrons et passons une limite pour corriger l'itération.
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); } } Sortir:
5 10 15 20 25
Exemple de flux Java : filtrage et itération de la collection
Dans l'exemple suivant, nous utilisons la méthode filter(). Ici, vous pouvez voir que le code est optimisé et très concis.
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)); } } Sortir:
Dell Laptop
Exemple de flux Java : méthode reduction() dans la collection
Cette méthode prend une séquence d’éléments d’entrée et les combine en un seul résultat récapitulatif par opération répétée. Par exemple, trouver la somme de nombres ou accumuler des éléments dans une liste.
Dans l'exemple suivant, nous utilisons la méthode réduire(), qui est utilisée pour additionner tous les prix des produits.
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); } } Sortir:
201000.0 201000.0
Exemple de flux Java : somme à l'aide de méthodes de collectionneurs
Nous pouvons également utiliser des collecteurs pour calculer la somme de valeurs numériques. Dans l'exemple suivant, nous utilisons la classe Collectors et ses méthodes spécifiées pour calculer la somme de tous les prix des produits.
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); } } Sortir:
201000.0
Exemple de flux Java : rechercher le prix maximum et minimum du produit
L'exemple suivant recherche le prix minimum et maximum du produit en utilisant le flux. Il fournit un moyen pratique de trouver des valeurs sans utiliser une approche impérative.
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); } } Sortir:
90000.0 25000.0
Exemple de flux Java : méthode count() dans la collection
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 vous permet de collecter votre résultat sous différentes formes. Vous pouvez obtenir votre résultat sous forme d’ensemble, de liste ou de carte et effectuer des manipulations sur les éléments.
Exemple de flux Java : convertir une liste en un ensemble
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); } } Sortir:
[25000.0, 28000.0]
Exemple de flux Java : convertir une liste en carte
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); } } Sortir:
{1=HP Laptop, 2=Dell Laptop, 3=Lenevo Laptop, 4=Sony Laptop, 5=Apple Laptop} Référence de méthode dans le flux
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); } } Sortir:
[90000.0]