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
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 | 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 |
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
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»
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
Recommended Posts