interface de type de fonction standard java

Une interface fonctionnelle est une interface qui n'a qu'une seule méthode abstraite et qui est utilisée comme destination d'affectation pour les expressions lambda et les références de méthode. J'ai essayé de résumer l'interface fonctionnelle standard

Interface fonctionnelle standard

En tant qu'interface de type de fonction standard, les types de méthode typiques sont définis dans le package java.util.function.

Interface fonctionnelle standard de base

interface	Méthode	La description
Function <T, R>	R apply (T t)	Prend un argument de type T et renvoie un résultat de type R
Consumer <T>	void accept (T t)	Reçoit des arguments de type T et ne renvoie aucun résultat
Predicate <T>	boolean test(T t)	Prend un argument de type T et renvoie le résultat de la valeur booléenne
Supplier <T>	T get()	Renvoie un résultat de type T sans argument

Exemple de code

`Sample.java`


        // Function<T, R>
        //Exemple: renvoie la longueur de chaîne de l'argument
        Function<String, Integer> function = String::length;
        System.out.println(function.apply("12345")); // 5

        // Consumer<T>
        //Exemple: affiche la longueur de chaîne de l'argument
        Consumer<String> consumer = str -> System.out.println(str.length());
        consumer.accept("12345"); // 5

        // Predicate<T>
        //Exemple: dans la chaîne d'argument"foo"Juger si est inclus
        Predicate<String> predicate = str -> Objects.nonNull(str) && str.contains("foo");
        System.out.println(predicate.test("foo bar")); // true

        // Supplier<T>
        //Exemple:"Sample"rends le
        Supplier<String> supplier = () -> "Sample";
        System.out.println(supplier.get()); // Sample

Composition des fonctions

Vous pouvez combiner des interfaces fonctionnelles standard pour créer de nouvelles interfaces fonctionnelles Synthétiser en utilisant compose, ʻandThen (La différence entre compose et ʻandThen est l'ordre de composition) Le système de prédicat peut être synthétisé en utilisant «et», «ou», «negate»

Exemple de code

`Sample.java`


        //Fonction composition de la fonction
        Function<String, Integer> function1 = String::length;
        Function<Integer, Integer> function2 = i -> i * 100;
        //Lors de l'utilisation de compose
        Function<String, Integer> newFunction1 = function2.compose(function1);
        //Lors de l'utilisation et
        Function<String, Integer> newFunction2 = function1.andThen(function2);
        System.out.println(newFunction1.apply("12345")); // 500
        System.out.println(newFunction2.apply("12345")); // 500

        //Composition de la fonction de prédicat
        Predicate<Integer> predicate1 = i -> i % 2 == 0; //Juger si c'est même
        Predicate<Integer> predicate2 = i -> i >= 100; //Juger si c'est 100 ou plus
        //Déterminez s'il est pair et 100 ou plus
        Predicate<Integer> newPredicate1 = predicate1.and(predicate2);
        //Déterminez si c'est impair et moins de 100(negate()Est un déni logique)
        Predicate<Integer> newPredicate2 = predicate1.negate().and(predicate2.negate());
        System.out.println(newPredicate1.test(100)); // true
        System.out.println(newPredicate2.test(99)); // true