Apprendre Prédicat : Filtrage des Données | Fondamentaux et Capacités Fonctionnelles de l'API Stream

L'objectif principal de Predicate est de permettre un filtrage des données pratique selon 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(), qui seront abordées 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 correspond à 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 sa parité.

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 ET

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 qu'il soit nécessaire de vérifier si un nombre est soit inférieur à 5 soit supérieur à 15.

La méthode or(), tout comme l'opérateur || en Java, permet de s'assurer qu'au moins une des conditions retourne 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 spécifiées. Ceci est utile lorsque la satisfaction d'un seul critère est suffisante.

Condition NÉGATIVE

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

Il est possible d'utiliser la méthode negate(), 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.

1. Quel est le but principal de l’interface fonctionnelle `Predicate` en Java ?

2. Quel sera le résultat de l’exécution du code suivant ?

Tout était clair ?

Merci pour vos commentaires !

Section 1. Chapitre 4

Demandez à l'IA

Posez n'importe quelle question ou essayez l'une des questions suggérées pour commencer notre discussion

Suggested prompts:

Can you show an example of using Predicate with numbers?

How do I combine multiple Predicate conditions?

What does the test() method do in practice?

Awesome!

Completion rate improved to 2.33

Glissez pour afficher le menu

@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(), qui seront abordées 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 correspond à 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.");
        }
    }
}

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

Combinaison de conditions

Condition ET

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 qu'il soit nécessaire de vérifier si un nombre est soit inférieur à 5 soit supérieur à 15.

La méthode or(), tout comme l'opérateur || en Java, permet de s'assurer qu'au moins une des conditions retourne 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 spécifiées. Ceci est utile lorsque la satisfaction d'un seul critère est suffisante.

Condition NÉGATIVE

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

Il est possible d'utiliser la méthode negate(), 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.

1. Quel est le but principal de l’interface fonctionnelle `Predicate` en Java ?

2. Quel sera le résultat de l’exécution du code suivant ?

Tout était clair ?

Merci pour vos commentaires !

Section 1. Chapitre 4

Prédicat : Filtrage des Données

Application pratique

Combinaison de conditions

Condition ET

Condition OU

Condition NÉGATIVE

1. Quel est le but principal de l’interface fonctionnelle Predicate en Java ?

2. Quel sera le résultat de l’exécution du code suivant ?

Awesome!

Prédicat : Filtrage des Données

Application pratique

Combinaison de conditions

Condition ET

Condition OU

Condition NÉGATIVE

1. Quel est le but principal de l’interface fonctionnelle Predicate en Java ?

2. Quel sera le résultat de l’exécution du code suivant ?

1. Quel est le but principal de l’interface fonctionnelle `Predicate` en Java ?

1. Quel est le but principal de l’interface fonctionnelle `Predicate` en Java ?