Qu'est-ce qu'un Predicate en Java
Ce tutoriel présente l’interface de Predicate avec des exemples en Java.
Le Predicate est une interface en Java utilisée comme affectation cible pour une expression lambda ou une référence de méthode. Il a été ajouté à Java 8 et a fourni une approche plus fonctionnelle de l’écriture de code en Java.
Il est présent dans le package java.util.function. Un Predicate est le plus souvent utilisé pour filtrer un flux d’objets. Dans ce didacticiel, nous expliquerons ce qu’est un Predicate et comment nous pouvons l’utiliser.
Qu’est-ce qu’un Predicate en Java
Comme indiqué précédemment, un Predicate est une interface fonctionnelle utilisée comme cible d’affectation pour une expression lambda ou une référence de méthode. L’interface Syntax of Predicate se présente comme suit.
@FunctionalInterface public interface Predicate<T>
Le T est le type d’entrée de l’interface de prédicat. Prenons un exemple de ce qu’est un prédicat. Dans le monde mathématique, un Predicate peut prendre la forme suivante :
x -> x > 90
La déclaration ci-dessus représente que x implique que x est supérieur à 90.
Voyons un exemple de la façon dont nous pouvons créer un objet de prédicat.
Predicate<Integer> noGreaterThan5 = x -> x > 5;
Dans le code ci-dessus, nous créons un Predicate nommé noGreaterThan5. Ce Predicate prend une entrée Integer ; par conséquent, T est un entier ici. Ce Predicate vérifiera si les arguments d’entrée sont supérieurs à cinq ou non.
Predicate dans Filter() Fonctionnement de Java Stream
L’opération filter() de l’API de flux Java 8 prend un Predicate comme argument. Dans le code ci-dessous, nous utiliserons l’opération filter() pour voir l’implémentation de l’interface de prédicat. Regardez le code ci-dessous :
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;
public class SimpleTesting {
public static void main(String args[]) {
// predicate
Predicate<String> nameGreaterThan4 = x -> x.length() > 4;
// Create a list
List<String> name = Arrays.asList("Ram", "Karan", "Aarya", "Rahul", "Om", "Pranav");
// create a stream
// apply filter operation
// pass the predicate
List<String> name_filtered =
name.stream().filter(nameGreaterThan4).collect(Collectors.toList());
// print the resulting list
System.out.println(name_filtered);
}
}
Production :
[Karan, Aarya, Rahul, Pranav]
Nous avons écrit le code ci-dessus pour filtrer les noms dont la longueur est supérieure à 4. Nous créons d’abord un Predicate et une List pour stocker les noms.
Nous créons ensuite un flux de noms à l’aide de la méthode List.toStream() et appliquons l’opération filter(). L’opération de filtrage prend le Predicate nameGreaterThan4 comme argument.
L’opération de filtrage utilisant ce Predicate n’autorisait que les chaînes dont la longueur était supérieure à 4. Les chaînes correspondant au Predicate étaient finalement collectées par l’opération de collecte et stockées dans une liste.
Au lieu de créer des objets de Predicate séparément, nous pouvons directement passer le Predicate dans la fonction de filtre. Regardez le code ci-dessous :
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;
public class SimpleTesting {
public static void main(String args[]) {
// Create a list
List<String> name = Arrays.asList("Ram", "Karan", "Aarya", "Rahul", "Om", "Pranav");
// create a stream
// apply filter operation
// pass the predicate
List<String> name_filtered =
name.stream().filter(x -> x.length() > 4).collect(Collectors.toList());
// print the resulting list
System.out.println(name_filtered);
}
}
Production :
[Karan, Aarya, Rahul, Pranav]
Méthode Predicate.and() en Java
Nous pouvons utiliser la méthode Predicate.and() pour appliquer deux prédicats à l’opération de filtrage. Il renvoie un Predicate composite qui reflète un ET logique de celui-ci et court-circuite un autre prédicat.
Si ce Predicate est false lors de l’évaluation du Predicate composite, l’autre Predicate n’est pas évalué. La signature de méthode de cette méthode est :
default Predicate<T> and(Predicate<? super T> other)
Autre dans l’argument fait référence au deuxième prédicat, que nous pouvons vouloir appliquer. Voyons maintenant quelques exemples pour en savoir plus sur cette méthode. Regardez le code ci-dessous :
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;
public class SimpleTesting {
public static void main(String args[]) {
// predicate
Predicate<String> nameGreaterThan3 = x -> x.length() > 3;
Predicate<String> nameLesserThan5 = x -> x.length() < 5;
// Create a list
List<String> name = Arrays.asList("Ram", "Karan", "Aarya", "Rahul", "Om", "Pranav", "Alok");
// create a stream
// apply filter operation
// pass the predicate
List<String> name_filtered =
name.stream().filter(nameGreaterThan3.and(nameLesserThan5)).collect(Collectors.toList());
// print the resulting list
System.out.println(name_filtered);
}
}
Production :
[Alok]
Dans le code ci-dessus, le premier Predicate vérifie si la longueur de la chaîne est supérieure à 3, et le second vérifie si la longueur de la chaîne est inférieure à 5. Lorsque ces deux prédicats sont passés à l’opération de filtrage avec l’opération ET, cela filtre les noms dont la longueur est égale à 4.
Le code ci-dessus peut être écrit de manière plus concise comme suit :
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;
public class SimpleTesting {
public static void main(String args[]) {
// create a list
List<String> name = Arrays.asList("Ram", "Karan", "Aarya", "Rahul", "Om", "Pranav", "Alok");
// create a stream
// apply filter operation
// pass the predicate
List<String> name_filtered =
name.stream().filter(x -> x.length() > 3 && x.length() < 5).collect(Collectors.toList());
// print the resulting list
System.out.println(name_filtered);
}
}
Production :
[Alok]
Méthode Predicate.or() en Java
Comme dans la discussion précédente, nous avons appliqué l’opération AND en utilisant la méthode AND. Nous pouvons également appliquer l’opération OR en utilisant la méthode or().
Il renvoie un Predicate composite qui reflète un OU logique de celui-ci et un autre Predicate qui court-circuite. Si ce Predicate est true, l’autre Predicate n’est pas pris en compte lors de l’évaluation du Predicate composite.
La signature de méthode de cette méthode est :
default Predicate<T> or(Predicate<? super T> other)
Autre dans l’argument fait référence au deuxième prédicat, que nous pouvons vouloir appliquer. Voyons maintenant quelques exemples pour en savoir plus sur cette méthode. Regardez le code ci-dessous :
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;
public class SimpleTesting {
public static void main(String args[]) {
// predicate
Predicate<String> nameEqualTo3 = x -> x.length() == 3;
Predicate<String> nameEqualTo2 = x -> x.length() == 2;
// Create a list
List<String> name = Arrays.asList("Ram", "Karan", "Aarya", "Rahul", "Om", "Pranav", "Alok");
// create a stream
// apply filter operation
// pass the predicate
List<String> name_filtered =
name.stream().filter(nameEqualTo3.or(nameEqualTo2)).collect(Collectors.toList());
// print the resulting list
System.out.println(name_filtered);
}
}
Production :
[Ram, Om]
Dans le code ci-dessus, le premier Predicate vérifie si la longueur de la chaîne est égale à 3, et le second Predicate vérifie si la longueur de la chaîne est égale à 5. Lorsque ces deux prédicats sont passés à l’opération de filtrage avec l’opération OU, cela filtre les noms dont la longueur est égale à 3 ou 2.
Le code ci-dessus peut être écrit de manière plus concise comme suit :
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;
public class SimpleTesting {
public static void main(String args[]) {
// Create a list
List<String> je_name = Arrays.asList("Ram", "Karan", "Aarya", "Rahul", "Om", "Pranav", "Alok");
// create a stream
// apply filter operation
// pass the predicate
List<String> je_name_filtered = je_name.stream()
.filter(x -> x.length() == 3 || x.length() == 2)
.collect(Collectors.toList());
// print the resulting list
System.out.println(je_name_filtered);
}
}
Production :
[Ram, Om]