Filtre de Stream en Java

1. Stream avec les méthodes filter() et collect() en Java
2. Stream avec les méthodes filter() et forEach() en Java
3. Stream avec filter() et plusieurs conditions en Java
4. Stream avec filter() et map() en Java
5. Stream avec empilement de plusieurs méthodes filter() en Java

Ce tutoriel présente l’API stream et sa méthode filter() en Java. En Java, un Stream est une collection d’objets.

Un Stream ne stocke aucune donnée et n’est donc pas une structure de données. Un Stream a diverses méthodes qui peuvent être mises en pipeline pour obtenir le résultat souhaité.

L’une de ces méthodes est la méthode filter. Nous verrons différents exemples utilisant l’opération filter de cet article.

Comprenons d’abord l’opération filter(). La méthode filter() renvoie un nouveau Stream avec des éléments qui correspondent au prédicat qui lui est passé en argument.

En d’autres termes, l’opération filter() est utilisée pour filtrer un Stream entrant et sortir un nouveau Stream. La syntaxe de cette méthode est :

Stream<T> filter(Predicate<? super T> predicate)

Un prédicat est une interface fonctionnelle, ce qui signifie que nous pouvons passer ici une fonction lambda ou une référence de méthode. Voyons maintenant quelques exemples.

Stream avec les méthodes filter() et collect() en Java

L’opération collect() est un type d’opération de terminal.

Les opérations terminales sont appliquées à un Stream à la fin pour produire un résultat. Après l’application d’un opérateur de terminal, le Stream est consommé et ne peut plus être consommé.

L’opération collect() renvoie la sortie des opérations intermédiaires ; il peut également être utilisé pour convertir la sortie dans la structure de données souhaitée. Regardez l’exemple ci-dessous.

Supposons que nous ayons une liste de tous les élèves d’une classe et que nous voulions créer une nouvelle liste contenant tous les noms des élèves sauf un. Supposons qu’un élève ait quitté l’école.

Nous pouvons le faire par ce code donné.

import java.util.*;
import java.util.stream.Collectors;
public class MyClass {
  public static void main(String args[]) {
    List<String> students = Arrays.asList("Kashish", "Riyan", "Ritu");

    List<String> new_students =
        students.stream().filter(sName -> !"Riyan".equals(sName)).collect(Collectors.toList());

    new_students.forEach(System.out::println);
  }
}

Production :

Kashish
Ritu

Dans ce code, tout d’abord, un Stream de noms d’étudiants est créé.

Le Stream est ensuite filtré à l’aide d’un prédicat : tous les noms différents de Riyan. L’opération filter génère un nouveau Stream avec tous les éléments satisfaisant ce prédicat.

Le Stream nouvellement créé est ensuite converti en une List à l’aide de l’opération collect.

Stream avec les méthodes filter() et forEach() en Java

La méthode forEach() est également une opération terminale. Il applique la fonction passée en argument à chaque élément de Stream.

Cela fonctionne comme une boucle foreach mais ne fonctionne que pour le Stream. Voir l’exemple ci-dessous.

Supposons que nous voulions imprimer tous les nombres divisibles par cinq. Le code ci-dessous fonctionne comme ça.

import java.util.*;
import java.util.stream.Collectors;
public class MyClass {
  public static void main(String args[]) {
    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 21, 11, 10, 25);

    numbers.stream().filter(n -> n % 5 == 0).forEach(System.out::println);
  }
}

Production :

5
10
25

Stream avec filter() et plusieurs conditions en Java

Nous pouvons passer plusieurs conditions dans l’opération filter() en utilisant des opérateurs logiques pour obtenir des résultats plus raffinés. Supposons que nous voulions trouver tous les éléments divisibles par cinq et supérieurs à dix ; voir l’exemple ci-dessous.

import java.util.*;
import java.util.stream.Collectors;
public class MyClass {
  public static void main(String args[]) {
    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 21, 11, 10, 25);

    numbers.stream().filter(n -> n % 5 == 0 && n > 10).forEach(System.out::println);
  }
}

Production :

25

Stream avec filter() et map() en Java

L’opération map() est similaire à l’opération forEach().

Il applique une fonction à chaque élément du Stream. C’est une opération intermédiaire plutôt qu’une opération terminale.

Supposons que nous devions élever au carré tous les éléments divisibles par 5. Nous pouvons le faire en pipelinant les opérations filter et map.

Voir l’exemple ci-dessous.

import java.util.*;
import java.util.stream.Collectors;
public class MyClass {
  public static void main(String args[]) {
    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 21, 11, 10, 25);

    List<Integer> new_numbers =
        numbers.stream().filter(n -> n % 5 == 0).map(x -> x * x).collect(Collectors.toList());

    new_numbers.forEach(System.out::println);
  }
}

Production :

25
100
625

Dans le code ci-dessus, tout d’abord, la liste des entiers est filtrée. Après filtrage de la liste, chaque élément restant dans le Stream est mis au carré à l’aide de l’opération map().

Enfin, nous convertissons le Stream dans la liste et le stockons dans la liste new_numbers.

Stream avec empilement de plusieurs méthodes filter() en Java

On peut empiler les méthodes filter() en les appliquant les unes après les autres pour obtenir un résultat plus raffiné.

Supposons que nous voulions d’abord filtrer les chaînes dont la longueur est supérieure à trois, puis filtrer les chaînes contenant stack comme sous-chaîne. Nous pouvons le faire en utilisant l’exemple de code ci-dessous.

import java.util.*;
import java.util.stream.Collectors;
public class MyClass {
  public static void main(String args[]) {
    List<String> str = Arrays.asList("Hello", "I", "Love", "Delftstack");

    List<String> new_string = str.stream()
                                  .filter(n -> n.length() > 3)
                                  .filter(n -> n.contains("stack"))
                                  .collect(Collectors.toList());

    new_string.forEach(System.out::println);
  }
}

Production :

Delftstack

Notez que le code ci-dessus équivaut à utiliser plusieurs conditions à l’aide de l’opérateur &&. Regardez ci-dessous:

import java.util.*;
import java.util.stream.Collectors;
public class MyClass {
  public static void main(String args[]) {
    List<String> str = Arrays.asList("Hello", "I", "Love", "Delftstack");

    List<String> new_string = str.stream()
                                  .filter(n -> n.length() > 3 && n.contains("stack"))
                                  .collect(Collectors.toList());

    new_string.forEach(System.out::println);
  }
}

Production :

Delftstack