Apprendre Prédicat : Filtrage des Données

Glissez pour afficher le menu

L'objectif principal de Predicate est de permettre un filtrage de données pratique basé sur une condition donnée. Cette interface fonctionnelle contient une seule méthode abstraite :

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
}

De plus, elle propose des méthodes par défaut pour combiner des conditions, telles que and(), or() et negate(), que nous aborderons ultérieurement.

Application pratique

La syntaxe de toutes les interfaces fonctionnelles suit un schéma similaire et reste très simple :

Predicate<T> predicate = t -> condition;

Ici, T désigne le type de l'argument d'entrée, et condition est une expression qui retourne soit true soit false.

Supposons qu'il soit nécessaire de vérifier si un nombre donné est pair. Il est possible d'utiliser un Predicate comme suit :

Main.java


              1234567891011121314151617
            
package com.example;

import java.util.function.Predicate;

public class Main {
    public static void main(String[] args) {
        // Condition: Check if a number is even
        Predicate<Integer> isEven = number -> number % 2 == 0;

        int number = 4;
        if (isEven.test(number)) {
            System.out.println(number + " is an even number.");
        } else {
            System.out.println(number + " is an odd number.");
        }
    }
}

Ce code utilise la méthode test() de l'interface Predicate, conçue pour évaluer des conditions. Lorsque test() est appelée, elle exécute la logique définie dans l'expression lambda number -> number % 2 == 0, vérifiant si le nombre est divisible par 2 sans reste, ce qui détermine s'il est pair.

Ici, Predicate est utilisé pour vérifier si un nombre est pair, et la méthode test() applique la condition.

Combinaison de conditions

Predicate offre la possibilité de combiner des conditions à l'aide des méthodes and(), or() et negate(). Cela permet d'effectuer des vérifications plus complexes. Voici quelques exemples :

Condition AND

Supposons qu'il soit nécessaire de vérifier si un nombre répond à deux critères : il doit être supérieur à 10 et pair.

La méthode and() peut être utilisée à cet effet, tout comme l’opérateur && en Java, afin de garantir que les deux conditions retournent true.

Main.java


              1234567891011121314151617181920212223
            
package com.example;

import java.util.function.Predicate;

public class Main {
    public static void main(String[] args) {
        // Condition 1: The number is greater than 10
        Predicate<Integer> isGreaterThanTen = number -> number > 10;

        // Condition 2: The number is even
        Predicate<Integer> isEven = number -> number % 2 == 0;

        // Combined condition: The number is greater than 10 and even
        Predicate<Integer> combinedCondition = isGreaterThanTen.and(isEven);

        int number = 12;
        if (combinedCondition.test(number)) {
            System.out.println(number + " meets both conditions.");
        } else {
            System.out.println(number + " does not meet the conditions.");
        }
    }
}

La méthode and() combine deux conditions. Un nombre doit satisfaire les deux critères pour que le résultat soit true.

Condition OU

Supposons maintenant que vous deviez vérifier si un nombre est soit inférieur à 5 soit supérieur à 15.

Vous pouvez utiliser la méthode or(), tout comme l'opérateur || en Java, pour garantir qu'au moins une des conditions renvoie true.

Main.java


              1234567891011121314151617181920212223
            
package com.example;

import java.util.function.Predicate;

public class Main {
    public static void main(String[] args) {
        // Condition 1: The number is less than 5
        Predicate<Integer> isLessThanFive = number -> number < 5;

        // Condition 2: The number is greater than 15
        Predicate<Integer> isGreaterThanFifteen = number -> number > 15;

        // Combined condition: The number is less than 5 or greater than 15
        Predicate<Integer> combinedCondition = isLessThanFive.or(isGreaterThanFifteen);

        int number = 3;
        if (combinedCondition.test(number)) {
            System.out.println(number + " meets at least one of the conditions.");
        } else {
            System.out.println(number + " does not meet any of the conditions.");
        }
    }
}

La méthode or() vérifie si un nombre satisfait au moins une des conditions données. Ceci est utile lorsque satisfaire à un seul critère suffit.

Condition NÉGATIVE

Supposons qu'il soit nécessaire de vérifier si une chaîne n'est pas vide.

La méthode negate() peut être utilisée, tout comme l'opérateur ! en Java, pour inverser le résultat d'une condition.

Main.java


              1234567891011121314151617181920
            
package com.example;

import java.util.function.Predicate;

public class Main {
    public static void main(String[] args) {
        // Condition: The string is empty
        Predicate<String> isEmpty = str -> str == null || str.isEmpty();

        // Condition: The string is not empty
        Predicate<String> isNotEmpty = isEmpty.negate();

        String text = "Hello";
        if (isNotEmpty.test(text)) {
            System.out.println("The string contains text: " + text);
        } else {
            System.out.println("The string is empty.");
        }
    }
}

La méthode negate() inverse une condition. Si la condition d'origine retourne true, la version négative retournera false, et inversement.