Notice: This page requires JavaScript to function properly.
Please enable JavaScript in your browser settings or update your browser.Apprendre Fonction : Transformation des Données | Fondamentaux et Capacités Fonctionnelles de l'API Stream
API Stream

bookFonction : Transformation des Données

Alors que Predicate nous aide à évaluer des expressions booléennes, Function permet de transformer des données en appliquant des opérations qui renvoient des résultats en fonction de l'entrée.

Function est couramment utilisé pour la transformation de données, comme la conversion de type, les calculs ou le traitement de valeurs.

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

L'interface Function<T, R> en Java représente une interface fonctionnelle qui prend un argument de type T et retourne un résultat de type R.

La méthode apply(T t) effectue la transformation des données en prenant la valeur d'entrée et en retournant le résultat. Cela permet de créer des fonctions flexibles pour traiter des données de différents types.

Application pratique

Supposons que vous disposiez d'une liste de noms d'utilisateurs, et que vous deviez calculer la longueur de chaque nom pour une analyse ou un traitement de données ultérieur.

Main.java

Main.java

copy

              
1234567891011121314151617

            
package com.example;

import java.util.Arrays;
import java.util.List;
import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        List<String> users = Arrays.asList("Alice", "Bob", "Charlie", "David");

        Function<String, Integer> nameLength = name -> name.length();

        users.forEach(user -> {
            System.out.println(user + " has " + nameLength.apply(user) + " characters.");
        });
    }
}

Dans cet exemple, une liste de noms d'utilisateurs est utilisée. Pour chaque nom, la fonction nameLength est appliquée, qui calcule le nombre de caractères dans le nom à l'aide de la méthode length(). À l'aide de la méthode forEach, chaque élément de la liste est parcouru et un message est affiché indiquant combien de caractères contient chaque nom.

Combinaison de fonctions

L'interface Function propose plusieurs méthodes pour la combinaison de fonctions, permettant de créer une chaîne d'opérations.

Méthode andThen()

La méthode andThen() permet de combiner deux fonctions en appliquant d'abord une fonction, puis en transmettant le résultat à la seconde fonction. Cette approche est utile lorsqu'il est nécessaire d'effectuer plusieurs opérations en séquence.

Exemple

Vous disposez d'une liste de noms d'utilisateurs, et vous devez mettre en majuscule la première lettre de chaque nom, puis vérifier si le nom comporte plus de 5 caractères.

Main.java

Main.java

copy

              
1234567891011121314151617181920212223

            
package com.example;

import java.util.Arrays;
import java.util.List;
import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        List<String> usernames = Arrays.asList("john", "alice", "bob", "charlie", "david");

        // Capitalize first letter
        Function<String, String> capitalizeFirstLetter = name -> name.substring(0, 1).toUpperCase() + name.substring(1);
        // Check if the username has more than 5 characters
        Function<String, Boolean> isLongerThanFive = name -> name.length() > 5;

        // Combine functions using `andThen()`
        Function<String, Boolean> formattedNameThenCheckLength = capitalizeFirstLetter.andThen(isLongerThanFive);

        usernames.forEach(user -> {
            System.out.println(user + " -> " + formattedNameThenCheckLength.apply(user));
        });
    }
}

Commencez par mettre en majuscule la première lettre de chaque nom d'utilisateur à l'aide de capitalizeFirstLetter. Ensuite, vérifiez si le nom d'utilisateur formaté comporte plus de 5 caractères à l'aide de isLongerThanFive. Les deux fonctions sont combinées avec andThen() pour un traitement séquentiel.

Méthode compose()

La méthode compose() permet de combiner des fonctions, mais dans l'ordre inverse : la deuxième fonction est appliquée en premier, puis le résultat est transmis à la première fonction.

Exemple

Vous disposez d'une chaîne de caractères et vous souhaitez d'abord calculer sa longueur, puis ajouter un préfixe au résultat.

Main.java

Main.java

copy

              
123456789101112131415161718

            
package com.example;

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        String phrase = "Hello World";

        // First, calculate the length, then add a prefix
        Function<String, Integer> stringLength = String::length;
        Function<Integer, String> addPrefix = length -> "Length: " + length;

        // Combine functions using compose
        Function<String, String> lengthThenPrefix = addPrefix.compose(stringLength);

        System.out.println(lengthThenPrefix.apply(phrase));  // Output: Length: 11
    }
}

Dans cet exemple, vous commencez par calculer la longueur de la chaîne à l'aide de stringLength, puis le résultat est transmis à la fonction addPrefix, qui ajoute un préfixe. Vous utilisez compose() pour appliquer les fonctions dans l'ordre souhaité.

Méthode identity()

La méthode identity() retourne une fonction qui renvoie simplement son argument sans aucune modification. Ceci est utile lorsque vous devez fournir une fonction qui ne modifie pas la valeur d'entrée mais qui est requise pour respecter l'interface.

Exemple

Supposons que vous deviez traiter une liste de noms d'utilisateur en appliquant plusieurs transformations : une pour convertir les noms en majuscules, une autre pour ajouter le suffixe "User", et une troisième utilisant la fonction identity() pour laisser le nom inchangé. L'objectif est d'appliquer ces fonctions à chaque nom de la liste tout en maintenant l'interface du programme cohérente pour chaque transformation.

Main.java

Main.java

copy

              
1234567891011121314151617181920212223242526272829303132

            
package com.example;

import java.util.List;
import java.util.Arrays;
import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        List<String> usernames = Arrays.asList("alice", "bob", "charlie", "david", "eve");

        // `Function` to convert the username to uppercase
        Function<String, String> uppercaseFunction = name -> name.toUpperCase();

        // `Function` to add the "User" suffix
        Function<String, String> suffixFunction = name -> name + "User";

        // Identity `Function`, which does nothing
        Function<String, String> identityFunction = Function.identity();

        // Applying a combination of functions
        List<Function<String, ?>> transformations = Arrays.asList(uppercaseFunction, suffixFunction, identityFunction);

        // Applying each `Function` from the list
        for (Function<String, ?> transformation : transformations) {
            System.out.println("--------------------");

            usernames.stream()
                .map(name -> transformation.apply(name))
                .forEach(System.out::println);
        }
    }
}

Comme vous pouvez le constater, la sortie se compose de trois listes formatées de noms d'utilisateur. La dernière liste contient les noms d'origine, c'est là que la méthode identity() s'avère utile, car elle permet de retourner les noms sans ajouter de logique supplémentaire pour gérer les valeurs inchangées. Cela rend le code plus clair et plus efficace en utilisant directement identity() lorsqu'aucune transformation n'est nécessaire.

1. Que fait la méthode andThen() dans l'interface Function ?

2. Quel sera le résultat lors de l'application de la méthode identity() ?

3. Que fait la méthode compose() ?

question mark

Que fait la méthode andThen() dans l'interface Function ?

Select the correct answer

question mark

Quel sera le résultat lors de l'application de la méthode identity() ?

Select the correct answer

question mark

Que fait la méthode compose() ?

Select the correct answer

Tout était clair ?

Comment pouvons-nous l'améliorer ?

Merci pour vos commentaires !

Section 1. Chapitre 6

Demandez à l'IA

expand

Demandez à l'IA

ChatGPT

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

bookFonction : Transformation des Données

Glissez pour afficher le menu

Alors que Predicate nous aide à évaluer des expressions booléennes, Function permet de transformer des données en appliquant des opérations qui renvoient des résultats en fonction de l'entrée.

Function est couramment utilisé pour la transformation de données, comme la conversion de type, les calculs ou le traitement de valeurs.

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

L'interface Function<T, R> en Java représente une interface fonctionnelle qui prend un argument de type T et retourne un résultat de type R.

La méthode apply(T t) effectue la transformation des données en prenant la valeur d'entrée et en retournant le résultat. Cela permet de créer des fonctions flexibles pour traiter des données de différents types.

Application pratique

Supposons que vous disposiez d'une liste de noms d'utilisateurs, et que vous deviez calculer la longueur de chaque nom pour une analyse ou un traitement de données ultérieur.

Main.java

Main.java

copy

              
1234567891011121314151617

            
package com.example;

import java.util.Arrays;
import java.util.List;
import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        List<String> users = Arrays.asList("Alice", "Bob", "Charlie", "David");

        Function<String, Integer> nameLength = name -> name.length();

        users.forEach(user -> {
            System.out.println(user + " has " + nameLength.apply(user) + " characters.");
        });
    }
}

Dans cet exemple, une liste de noms d'utilisateurs est utilisée. Pour chaque nom, la fonction nameLength est appliquée, qui calcule le nombre de caractères dans le nom à l'aide de la méthode length(). À l'aide de la méthode forEach, chaque élément de la liste est parcouru et un message est affiché indiquant combien de caractères contient chaque nom.

Combinaison de fonctions

L'interface Function propose plusieurs méthodes pour la combinaison de fonctions, permettant de créer une chaîne d'opérations.

Méthode andThen()

La méthode andThen() permet de combiner deux fonctions en appliquant d'abord une fonction, puis en transmettant le résultat à la seconde fonction. Cette approche est utile lorsqu'il est nécessaire d'effectuer plusieurs opérations en séquence.

Exemple

Vous disposez d'une liste de noms d'utilisateurs, et vous devez mettre en majuscule la première lettre de chaque nom, puis vérifier si le nom comporte plus de 5 caractères.

Main.java

Main.java

copy

              
1234567891011121314151617181920212223

            
package com.example;

import java.util.Arrays;
import java.util.List;
import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        List<String> usernames = Arrays.asList("john", "alice", "bob", "charlie", "david");

        // Capitalize first letter
        Function<String, String> capitalizeFirstLetter = name -> name.substring(0, 1).toUpperCase() + name.substring(1);
        // Check if the username has more than 5 characters
        Function<String, Boolean> isLongerThanFive = name -> name.length() > 5;

        // Combine functions using `andThen()`
        Function<String, Boolean> formattedNameThenCheckLength = capitalizeFirstLetter.andThen(isLongerThanFive);

        usernames.forEach(user -> {
            System.out.println(user + " -> " + formattedNameThenCheckLength.apply(user));
        });
    }
}

Commencez par mettre en majuscule la première lettre de chaque nom d'utilisateur à l'aide de capitalizeFirstLetter. Ensuite, vérifiez si le nom d'utilisateur formaté comporte plus de 5 caractères à l'aide de isLongerThanFive. Les deux fonctions sont combinées avec andThen() pour un traitement séquentiel.

Méthode compose()

La méthode compose() permet de combiner des fonctions, mais dans l'ordre inverse : la deuxième fonction est appliquée en premier, puis le résultat est transmis à la première fonction.

Exemple

Vous disposez d'une chaîne de caractères et vous souhaitez d'abord calculer sa longueur, puis ajouter un préfixe au résultat.

Main.java

Main.java

copy

              
123456789101112131415161718

            
package com.example;

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        String phrase = "Hello World";

        // First, calculate the length, then add a prefix
        Function<String, Integer> stringLength = String::length;
        Function<Integer, String> addPrefix = length -> "Length: " + length;

        // Combine functions using compose
        Function<String, String> lengthThenPrefix = addPrefix.compose(stringLength);

        System.out.println(lengthThenPrefix.apply(phrase));  // Output: Length: 11
    }
}

Dans cet exemple, vous commencez par calculer la longueur de la chaîne à l'aide de stringLength, puis le résultat est transmis à la fonction addPrefix, qui ajoute un préfixe. Vous utilisez compose() pour appliquer les fonctions dans l'ordre souhaité.

Méthode identity()

La méthode identity() retourne une fonction qui renvoie simplement son argument sans aucune modification. Ceci est utile lorsque vous devez fournir une fonction qui ne modifie pas la valeur d'entrée mais qui est requise pour respecter l'interface.

Exemple

Supposons que vous deviez traiter une liste de noms d'utilisateur en appliquant plusieurs transformations : une pour convertir les noms en majuscules, une autre pour ajouter le suffixe "User", et une troisième utilisant la fonction identity() pour laisser le nom inchangé. L'objectif est d'appliquer ces fonctions à chaque nom de la liste tout en maintenant l'interface du programme cohérente pour chaque transformation.

Main.java

Main.java

copy

              
1234567891011121314151617181920212223242526272829303132

            
package com.example;

import java.util.List;
import java.util.Arrays;
import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        List<String> usernames = Arrays.asList("alice", "bob", "charlie", "david", "eve");

        // `Function` to convert the username to uppercase
        Function<String, String> uppercaseFunction = name -> name.toUpperCase();

        // `Function` to add the "User" suffix
        Function<String, String> suffixFunction = name -> name + "User";

        // Identity `Function`, which does nothing
        Function<String, String> identityFunction = Function.identity();

        // Applying a combination of functions
        List<Function<String, ?>> transformations = Arrays.asList(uppercaseFunction, suffixFunction, identityFunction);

        // Applying each `Function` from the list
        for (Function<String, ?> transformation : transformations) {
            System.out.println("--------------------");

            usernames.stream()
                .map(name -> transformation.apply(name))
                .forEach(System.out::println);
        }
    }
}

Comme vous pouvez le constater, la sortie se compose de trois listes formatées de noms d'utilisateur. La dernière liste contient les noms d'origine, c'est là que la méthode identity() s'avère utile, car elle permet de retourner les noms sans ajouter de logique supplémentaire pour gérer les valeurs inchangées. Cela rend le code plus clair et plus efficace en utilisant directement identity() lorsqu'aucune transformation n'est nécessaire.

1. Que fait la méthode andThen() dans l'interface Function ?

2. Quel sera le résultat lors de l'application de la méthode identity() ?

3. Que fait la méthode compose() ?

question mark

Que fait la méthode andThen() dans l'interface Function ?

Select the correct answer

question mark

Quel sera le résultat lors de l'application de la méthode identity() ?

Select the correct answer

question mark

Que fait la méthode compose() ?

Select the correct answer

Tout était clair ?

Comment pouvons-nous l'améliorer ?

Merci pour vos commentaires !

Section 1. Chapitre 6
some-alt