Filtre de flux Java

Stream.filter() est une méthode en Java que nous utilisons lorsque nous travaillons avec des flux. Il parcourt tous les éléments présents et supprime ou filtre tous les éléments qui ne correspondent pas à la condition spécifiée via un argument significatif. Il s'agit essentiellement d'une opération qui a lieu entre l'interface de flux. La fonction renvoie un flux de sortie dont les éléments du flux d'entrée correspondent aux conditions données.

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

L'argument passé avec filter() sera un prédicat apatride et s'appliquera à chaque élément pour identifier s'il doit être inclus ou non. Nous pouvons également transmettre l'expression lambda à travers cela puisque le prédicat relève de la catégorie de l'interface fonctionnelle. La sortie contient un nouveau flux qui peut être utilisé pour toute autre opération pertinente à n'importe quel flux.

Syntaxe :

Stream<T> filter(Predicate<? super T> condition)d

Le prédicat représente une interface fonctionnelle et montre la condition que nous utilisons pour filtrer les éléments qui ne correspondent pas au flux.

Exemples d'implémentation du filtre de flux Java

Prenons quelques exemples pour comprendre la fonctionnalité de la fonction Java stream().

Exemple n°1

Code :

import java.util.Arrays;
import java.util.List;
public class Main
{
public static void main(String[] args)
{
List<Integer> arr = Arrays.asList(11, 12, 13, 14, 15, 16, 17, 18, 19, 20);
arr.stream()
.filter(i -> i % 3 == 0)
.forEach(System.out::println);
}
}

Sortie :

Explication : Il s'agit d'un exemple très basique et simple qui montre comment utiliser la fonction de filtre de flux Java. Dans cet exemple, nous déclarons un tableau de nombres aléatoires et les attribuons à une liste. Ensuite, nous utilisons le filtre de flux pour filtrer tous les éléments du tableau donné qui satisfont à la condition donnée, c'est-à-dire que tous les nombres du tableau qui donnent un module de 3 à 0 sont filtrés et affichés dans la sortie.

Exemple n°2

Code :

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
public class Main
{
public static void main(String[] args)
{
List<Integer> arr = Arrays.asList(21, 22, 23, 24, 25, 26, 27, 28, 29, 30);
Predicate<Integer> condition = new Predicate<Integer>()
{
@Override
public boolean test(Integer i) {
if (i % 4 == 0) {
return true;
}
return false;
}
};
arr.stream().filter(condition).forEach(System.out::println);
}
}

Sortie :

Explication : Dans cet exemple, nous déclarons d'abord un tableau d'entrée composé d'un ensemble aléatoire de nombres et leur attribuons une liste. Ici, nous montrons également comment utiliser et déclarer le prédicat avec la fonction de filtre de flux en créant d'abord un objet de la même condition de nom. Ensuite, une classe du nom test ayant un paramètre d'entrée entier I est créée où nous vérifions le module de 4 du tableau donné. Cette fonction renvoie une valeur booléenne vraie si les modules de 4 renvoient 0 et faux sinon. En prenant cette valeur de retour, la fonction stream est ensuite utilisée pour récupérer les éléments du tableau dont la condition est vraie.

Exemple #3

Code :

import java.util.*;
public class Example {
public static void main(String[] args) {
//Array creation
List<String> arr1 = Arrays.asList("trial", "simple", "node");
//Calling usingFiltOutput function
List<String> op = usingFiltOutput(arr1, "node");
//for loop to print array
for (String arr : op) {
System.out.print(arr);
System.out.print("\n");
}
}
private static List<String> usingFiltOutput(List<String> arr2, String filter) {
List<String> op = new ArrayList<>();
for (String arr1 : arr2) {
if (!"node".equals(arr1)) {
op.add(arr1);
}
}
return op;
}
}

Sortie :

Explication : Dans l'exemple ci-dessus, nous montrons le filtrage des éléments du tableau où nous filtrons l'élément « nœud » en utilisant la méthode de filtrage de flux

Exemple n°4

Code :

import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<Car> listCar = new ArrayList<>();
listCar.add(new Car("Maruti", 350000));
listCar.add(new Car("Toyota", 400000));
listCar.add(new Car("Mahindra", 500000));
listCar.add(new Car("Honda", 600000));
// displaying all cars with cost more than 4lakh
listCar.stream().filter(c -> (c.getID() > 400000))
.forEach(c -> System.out.println(c.getCompany()));
}
}
class Car {
private String company;
private int ID;
public Car() {
}
public Car(String n, int a) {
this.company = n;
this.ID = a;
}
public String getCompany() {
return company;
}
public void setCompany(String company) {
this.company = company;
}
public int getID() {
return ID;
}
public void setID(int ID) {
this.ID = ID;
}
}

Sortie :

Explication : Dans cet exemple, nous verrons une sorte d'application en temps réel où la liste des différentes sociétés de voitures et leur coût de base a été affectée à une liste de tableaux comme indiqué. Ensuite, nous définissons quelques méthodes ci-dessous pour récupérer les valeurs individuelles de la liste des tableaux. La méthode getcost est utilisée pour obtenir le coût de cette voiture particulière, et getCompany est utilisée pour obtenir le nom de l'entreprise à partir de la liste du tableau d'entrée. Ensuite, dans la fonction principale, nous utilisons la fonction de filtre de flux Java pour récupérer uniquement les noms de constructeurs automobiles dont le coût approximatif est supérieur à Rs.400000.

Exemple #5

Code :

import java.util.*;
import java.util.stream.Collectors;
class Example{
int pro_id;
String pro_name;
float pro_cost;
public Example(int pro_id, String pro_name, float pro_cost) {
this.pro_id = pro_id;
this.pro_name = pro_name;
this.pro_cost = pro_cost;
}
}
public class JavaStreamExample {
public static void main(String[] args) {
List<Example> productsList = new ArrayList<Example>();
//Here we are listing the products
productsList.add(new Example(1,"Shirt",1500f));
productsList.add(new Example(2,"Long Sleeve Top",1000f));
productsList.add(new Example(3,"Crop Top",1600f));
productsList.add(new Example(4,"Jeans",2100f));
productsList.add(new Example(5,"Skirt",1800f));
List<Float> pricesList = productsList.stream()
.filter(p ->p.pro_cost> 1500)
.map(pm ->pm.pro_cost)
.collect(Collectors.toList());
System.out.println(pricesList);
}
}

Sortie :

Explication : Dans cet exemple, nous déclarons d'abord quelques paramètres concernant les produits d'une boutique de vêtements, tels que l'identifiant du produit, le nom et le coût. Et en utilisant ArrayList, nous y ajoutons certains produits ainsi que ses paramètres. En fin de compte, en utilisant le filtre de flux Java, nous filtrons quelques produits dont le coût est supérieur à Rs.1500. Cela montre une application en temps réel de cette méthode.

Conclusion

Nous avons vu tous les différents types de combinaisons avec lesquelles le filtre de flux Java peut être utilisé pour filtrer certains éléments du tableau en fonction de la condition que nous donnons. Il peut également être combiné avec des flux Java, des listes de tableaux, des collections et bien d'autres en fonction des besoins.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!