Apprendre Bi-Versions des Interfaces Fonctionnelles | Fondamentaux et Capacités Fonctionnelles de l'API Stream

En Java, il existe plusieurs interfaces fonctionnelles bi-versions qui travaillent avec deux arguments. Ces interfaces offrent des modèles pratiques pour effectuer diverses opérations sur une paire de données d'entrée, que ce soit pour calculer un résultat, effectuer une action ou vérifier une condition.

Elles simplifient la gestion de scénarios complexes où il est nécessaire de manipuler deux paramètres simultanément.

Par exemple, au lieu d'écrire un code volumineux avec de multiples appels imbriqués, il est possible de profiter d'interfaces concises qui proposent des méthodes prêtes à l'emploi pour implémenter les fonctionnalités clés.

BiFunction<T, U, R>

BiFunction est une interface fonctionnelle qui prend deux arguments d'entrée de types T et U, et retourne un résultat de type R.

@FunctionalInterface
public interface BiFunction<T, U, R> {
    R apply(T t, U u);
}

BiFunction est idéal pour les tâches où deux valeurs doivent être traitées et un résultat dérivé est retourné, comme le calcul, la transformation ou la combinaison de données.

Par exemple, si vous devez calculer le coût total des articles en stock en multipliant la quantité par le prix unitaire :

Main.java


              1234567891011121314151617
            
package com.example;

import java.util.function.BiFunction;

public class Main {
    public static void main(String[] args) {
       // `BiFunction` to calculate total cost
       BiFunction<Integer, Double, Double> calculateTotalCost = (quantity, pricePerUnit) -> quantity * pricePerUnit;

       // Example usage
       int quantity = 50;
       double pricePerUnit = 19.99;
       double totalCost = calculateTotalCost.apply(quantity, pricePerUnit);

       System.out.println("Total cost: $" + totalCost);
    }
}

Dans cet exemple, BiFunction<Integer, Double, Double> accepte deux arguments : quantity et pricePerUnit (prix par unité), et retourne le résultat — le coût total sous forme de valeur Double. La méthode apply() effectue l’opération spécifiée, reliant l’interface fonctionnelle à la logique de multiplication.

BiConsumer<T, U>

BiConsumer est une interface fonctionnelle qui prend deux arguments de types T et U, mais ne retourne aucun résultat.

@FunctionalInterface
public interface BiConsumer<T, U> {
    void accept(T t, U u);
}

Utilisé pour effectuer des actions sur deux objets, telles que l'enregistrement des journaux, l'affichage d'informations ou la sauvegarde de données.

Par exemple, création d'une interface fonctionnelle acceptant le nom d'un employé et son salaire, formatant les données et les affichant dans la console :

Main.java


              1234567891011121314151617181920212223242526
            
package com.example;

import java.util.HashMap;
import java.util.Map;
import java.util.function.BiConsumer;

public class Main {
    public static void main(String[] args) {
        // `BiConsumer` for formatted output of employee details
        BiConsumer<String, Double> printEmployeeDetails = (name, salary) -> {
            System.out.printf("Employee: %-15s | Salary: $%.2f%n", name, salary);
        };

        // Collection of employees with their salaries
        Map<String, Double> employeeData = new HashMap<>();
        employeeData.put("John Smith", 75000.0);
        employeeData.put("Mary Johnson", 82000.0);
        employeeData.put("Robert Brown", 64000.0);
        employeeData.put("Emily Davis", 91000.0);

        // Print details of each employee
        System.out.println("Employee Salary Report:");
        System.out.println("-----------------------------------");
        employeeData.forEach(printEmployeeDetails);
    }
}

Dans cet exemple, BiConsumer<String, Double> est utilisé pour traiter le nom de l'employé et son salaire, en affichant les données dans la console de manière formatée.

La méthode forEach() de la collection Map transmet chaque paire clé-valeur au BiConsumer, qui effectue l'action spécifiée pour tous les employés.

BiPredicate<T, U>

BiPredicate est une interface fonctionnelle qui prend deux arguments de types T et U et retourne un résultat booléen.

@FunctionalInterface
public interface BiPredicate<T, U> {
    boolean test(T t, U u);
}

Elle est utilisée pour vérifier des conditions dont le résultat est une valeur booléenne (true ou false), basée sur l'analyse de deux valeurs d'entrée.

Par exemple, vérification si la longueur d'une chaîne est supérieure à un nombre donné :

Main.java


              1234567891011121314151617
            
package com.example;

import java.util.function.BiPredicate;

public class Main {
    public static void main(String[] args) {
        // `BiPredicate` to check if string length is greater than given number
        BiPredicate<String, Integer> isStringLongerThan = (str, length) -> str.length() > length;

        // Example usage
        String text = "Sample string";
        int minLength = 10;
        boolean result = isStringLongerThan.test(text, minLength);

        System.out.println("String is longer than " + minLength + " characters: " + result);
    }
}

Dans cet exemple, BiPredicate<String, Integer> accepte deux arguments : la chaîne de caractères str et le nombre length, représentant la longueur minimale. La méthode test() vérifie la condition et retourne true si la longueur de la chaîne est supérieure au nombre spécifié, ou false dans le cas contraire.

1. Quelle méthode est la principale dans l'interface `BiFunction<T, U, R>` ?

2. Que retourne la méthode `accept(T t, U u)` de l'interface `BiConsumer<T, U>` ?

3. Quelle interface est utilisée pour vérifier une condition logique avec deux arguments ?

Tout était clair ?

Merci pour vos commentaires !

Section 1. Chapitre 13

Demandez à l'IA

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

Awesome!

Completion rate improved to 2.33

Glissez pour afficher le menu

Elles simplifient la gestion de scénarios complexes où il est nécessaire de manipuler deux paramètres simultanément.

BiFunction<T, U, R>

BiFunction est une interface fonctionnelle qui prend deux arguments d'entrée de types T et U, et retourne un résultat de type R.

@FunctionalInterface
public interface BiFunction<T, U, R> {
    R apply(T t, U u);
}

Par exemple, si vous devez calculer le coût total des articles en stock en multipliant la quantité par le prix unitaire :

Main.java


              1234567891011121314151617
            
package com.example;

import java.util.function.BiFunction;

public class Main {
    public static void main(String[] args) {
       // `BiFunction` to calculate total cost
       BiFunction<Integer, Double, Double> calculateTotalCost = (quantity, pricePerUnit) -> quantity * pricePerUnit;

       // Example usage
       int quantity = 50;
       double pricePerUnit = 19.99;
       double totalCost = calculateTotalCost.apply(quantity, pricePerUnit);

       System.out.println("Total cost: $" + totalCost);
    }
}

BiConsumer<T, U>

BiConsumer est une interface fonctionnelle qui prend deux arguments de types T et U, mais ne retourne aucun résultat.

@FunctionalInterface
public interface BiConsumer<T, U> {
    void accept(T t, U u);
}

Utilisé pour effectuer des actions sur deux objets, telles que l'enregistrement des journaux, l'affichage d'informations ou la sauvegarde de données.

Par exemple, création d'une interface fonctionnelle acceptant le nom d'un employé et son salaire, formatant les données et les affichant dans la console :

Main.java


              1234567891011121314151617181920212223242526
            
package com.example;

import java.util.HashMap;
import java.util.Map;
import java.util.function.BiConsumer;

public class Main {
    public static void main(String[] args) {
        // `BiConsumer` for formatted output of employee details
        BiConsumer<String, Double> printEmployeeDetails = (name, salary) -> {
            System.out.printf("Employee: %-15s | Salary: $%.2f%n", name, salary);
        };

        // Collection of employees with their salaries
        Map<String, Double> employeeData = new HashMap<>();
        employeeData.put("John Smith", 75000.0);
        employeeData.put("Mary Johnson", 82000.0);
        employeeData.put("Robert Brown", 64000.0);
        employeeData.put("Emily Davis", 91000.0);

        // Print details of each employee
        System.out.println("Employee Salary Report:");
        System.out.println("-----------------------------------");
        employeeData.forEach(printEmployeeDetails);
    }
}

Dans cet exemple, BiConsumer<String, Double> est utilisé pour traiter le nom de l'employé et son salaire, en affichant les données dans la console de manière formatée.

La méthode forEach() de la collection Map transmet chaque paire clé-valeur au BiConsumer, qui effectue l'action spécifiée pour tous les employés.

BiPredicate<T, U>

BiPredicate est une interface fonctionnelle qui prend deux arguments de types T et U et retourne un résultat booléen.

@FunctionalInterface
public interface BiPredicate<T, U> {
    boolean test(T t, U u);
}

Elle est utilisée pour vérifier des conditions dont le résultat est une valeur booléenne (true ou false), basée sur l'analyse de deux valeurs d'entrée.

Par exemple, vérification si la longueur d'une chaîne est supérieure à un nombre donné :

Main.java


              1234567891011121314151617
            
package com.example;

import java.util.function.BiPredicate;

public class Main {
    public static void main(String[] args) {
        // `BiPredicate` to check if string length is greater than given number
        BiPredicate<String, Integer> isStringLongerThan = (str, length) -> str.length() > length;

        // Example usage
        String text = "Sample string";
        int minLength = 10;
        boolean result = isStringLongerThan.test(text, minLength);

        System.out.println("String is longer than " + minLength + " characters: " + result);
    }
}

1. Quelle méthode est la principale dans l'interface `BiFunction<T, U, R>` ?

2. Que retourne la méthode `accept(T t, U u)` de l'interface `BiConsumer<T, U>` ?

3. Quelle interface est utilisée pour vérifier une condition logique avec deux arguments ?

Tout était clair ?

Merci pour vos commentaires !

Section 1. Chapitre 13

Bi-Versions des Interfaces Fonctionnelles

BiFunction<T, U, R>

BiConsumer<T, U>

BiPredicate<T, U>

1. Quelle méthode est la principale dans l'interface BiFunction<T, U, R> ?

2. Que retourne la méthode accept(T t, U u) de l'interface BiConsumer<T, U> ?

3. Quelle interface est utilisée pour vérifier une condition logique avec deux arguments ?

Awesome!

Bi-Versions des Interfaces Fonctionnelles

BiFunction<T, U, R>

BiConsumer<T, U>

BiPredicate<T, U>

1. Quelle méthode est la principale dans l'interface BiFunction<T, U, R> ?

2. Que retourne la méthode accept(T t, U u) de l'interface BiConsumer<T, U> ?

3. Quelle interface est utilisée pour vérifier une condition logique avec deux arguments ?

1. Quelle méthode est la principale dans l'interface `BiFunction<T, U, R>` ?

2. Que retourne la méthode `accept(T t, U u)` de l'interface `BiConsumer<T, U>` ?

1. Quelle méthode est la principale dans l'interface `BiFunction<T, U, R>` ?

2. Que retourne la méthode `accept(T t, U u)` de l'interface `BiConsumer<T, U>` ?