Une interface fonctionnelle est une interface qui déclare une seule méthode abstraite.
Cette méthode abstraite est appelée la méthode fonctionnelle de l'interface fonctionnelle.
Une interface fonctionnelle peut cependant déclarer d'autres méthodes non abstraites mais doit fournir une implementation par défaut (default) à toutes ces méthodes.
Une interface fonctionnelle peut aussi définir des méthodes statiques.

Une interface fonctionnelle peut être annotées par l'annotation "@FunctionalInterface" pour être explicite sur le fait qu'il s'agit d'une interface fonctionnelle.
Par défaut, les interfaces qui déclarent une seule méthode abstraite, sont considérées des interfaces fonctionnelles.

Exemple: java.util.function.Predicate
@FunctionalInterface public interface Predicate<T> { boolean test(T t); default Predicate<T> and(Predicate<? super T> other) { Objects.requireNonNull(other); return (t) -> test(t) && other.test(t); } default Predicate<T> negate() { return (t) -> !test(t); } default Predicate<T> or(Predicate<? super T> other) { Objects.requireNonNull(other); return (t) -> test(t) || other.test(t); } static <T> Predicate<T> isEqual(Object targetRef) { return (null == targetRef) ? Objects::isNull : object -> targetRef.equals(object); } }

La librairie Java fournit une liste des interfaces fonctionnelles qui se trouvent dans le package "java.util.function":

• Predicate<T>: boolean test(T t)
  Cette interface définit une méthode fonctionnelle "boolean test(T t)" qui declare un seul paramètre ("t" de type "T") et retourne vrais/faux.
  L'implementation doit, typiquement, appliquer une logique autour de la valeur de l'argument "t".
  Predicate<Integer> isOdd = t -> t % 2 == 0; System.out.println(isOdd.test(1)); Predicate<Integer> isEven = isOdd.negate(); System.out.println(isEven.test(1));
  
  • IntPredicate: boolean test(int t)
    Cette interface est une spécialisation de l'interface fonctionnelle "Predicate" en spécifiant le type du parameter "t" a "int".
    
    
  • LongPredicate: boolean test(long t)
    Cette interface est une spécialisation de l'interface fonctionnelle "Predicate" en spécifiant le type du parameter "t" a "long".
    
    
  • DoublePredicate: boolean test(double t)
    Cette interface est une spécialisation de l'interface fonctionnelle "Predicate" en spécifiant le type du parameter "t" a "double".
    
  
  
• BiPredicate<T, U>: boolean test(T t, U u)
  Cette interface définit une méthode fonctionnelle "boolean test(T t, U u)" qui declare deux paramètres ("t" de type "T", "u" de type "U") et retourne vrais/faux.
  L'implementation doit, typiquement, appliquer une logique autour de la valeur des arguments "t" et "u".
  BiPredicate<Object, Object> equals = (a, b) -> Objects.equals(a, b); System.out.println(equals.test(1, 2)); BiPredicate<Object, Object> deepEquals = Objects::deepEquals; System.out.println(deepEquals.test(1, 2));
  
• Consumer<T>: void accept(T t)
  Cette interface définit une méthode fonctionnelle "void accept(T t)" qui declare un seul paramètre ("t" de type "T") et ne retourne pas de valeur.
  L'implementation doit, typiquement, consommer la valeur de l'argument "t" et produit un effet de bord sans retourner de valeur.
  Consumer<String> println = t -> System.out.println(t); println.accept("test");
  
  • IntConsumer: void accept(int t)
    Cette interface est une spécialisation de l'interface fonctionnelle "Consumer" en spécifiant le type du parameter "t" a "int".
    
    
  • LongConsumer: void accept(long t)
    Cette interface est une spécialisation de l'interface fonctionnelle "Consumer" en spécifiant le type du parameter "t" a "long".
    
    
  • DoubleConsumer: void accept(double t)
    Cette interface est une spécialisation de l'interface fonctionnelle "Consumer" en spécifiant le type du parameter "t" a "double".
    
  
  
• BiConsumer<T, U>: void accept(T t, U u)
  Cette interface définit une méthode fonctionnelle "void accept(T t, U u)" qui declare deux paramètres ("t" de type "T", "u" de type "U") et ne retourne pas de valeur.
  L'implementation doit, typiquement, consommer les valeurs des arguments "t" et "u" et produit un effet de bord sans retourner de valeur.
  BiConsumer<String, String> printlnIfElse = (a, b) -> System.out.println(a == null ? b : a); printlnIfElse.accept(null, "test");
  
  • ObjIntConsumer<T>: void accept(T t, int u)
    Cette interface est une spécialisation de l'interface fonctionnelle "BiConsumer" en spécifiant le type du parameter "u" a "int".
    
    
  • ObjLongConsumer<T>: void accept(T t, long u)
    Cette interface est une spécialisation de l'interface fonctionnelle "BiConsumer" en spécifiant le type du parameter "u" a "long".
    
    
  • ObjDoubleConsumer<T>: void accept(T t, double u)
    Cette interface est une spécialisation de l'interface fonctionnelle "BiConsumer" en spécifiant le type du parameter "u" a "double".
    
  
  
• Supplier<T>: T get()
  Cette interface définit une méthode fonctionnelle "T get()" qui ne declare aucun paramètre et l'implementation doit fournir une valuer de type "T".
  Supplier<Double> random = () -> Math.random(); System.out.println(random.get());
  
  • BooleanSupplier: boolean getAsBoolean()
    Cette interface est une spécialisation de l'interface fonctionnelle "Supplier" en spécifiant la valeur fournit a "boolean".
    
    
  • IntSupplier: int getAsInt()
    Cette interface est une spécialisation de l'interface fonctionnelle "Supplier" en spécifiant la valeur fournit a "int".
    
    
  • LongSupplier: long getAsLong()
    Cette interface est une spécialisation de l'interface fonctionnelle "Supplier" en spécifiant la valeur fournit a "long".
    
    
  • DoubleSupplier: double getAsDouble()
    Cette interface est une spécialisation de l'interface fonctionnelle "Supplier" en spécifiant la valeur fournit a "double".
    
  
  
• Function<T, R>: R apply(T t)
  Cette interface définit une méthode fonctionnelle "R apply(T t)" qui declare un seul paramètre ("t" de type "T") et retourne une valeur de type "R".
  L'implementation doit, typiquement, appliquer une logique autour de la valeur de l'argument "t".
  
  Function<Integer, String> valueOf = t -> "id-".concat(String.valueOf(t)); System.out.println(valueOf.apply(15));
  

  ---

  
  
  • IntFunction<R>: R apply(int t)
    Cette interface est une spécialisation de l'interface fonctionnelle "Function" en spécifiant le type du parameter "t" a "int".
    
    
  • LongFunction<R>: R apply(long t)
    Cette interface est une spécialisation de l'interface fonctionnelle "Function" en spécifiant le type du parameter "t" a "long".
    
    
  • DoubleFunction<R>: R apply(double t)
    Cette interface est une spécialisation de l'interface fonctionnelle "Function" en spécifiant le type du parameter "t" a "double".
    
    

  ---

  
  
  • ToIntFunction<T>: int applyAsInt(T t)
    Cette interface est une spécialisation de l'interface fonctionnelle "Function" en spécifiant la valeur de retour a "int".
    
    
  • ToLongFunction<T>: long applyAsLong(T t)
    Cette interface est une spécialisation de l'interface fonctionnelle "Function" en spécifiant la valeur de retour a "long".
    
    
  • ToDoubleFunction<T>: double applyAsDouble(T t)
    Cette interface est une spécialisation de l'interface fonctionnelle "Function" en spécifiant la valeur de retour a "double".
    
    

  ---

  
  
  • IntToLongFunction: long applyAsLong(int t)
    Cette interface est une spécialisation de l'interface fonctionnelle "Function" en spécifiant le type du parameter "t" a "int" et en spécifiant la valeur de retour a "long".
    
    
  • IntToDoubleFunction: double applyAsDouble(int t)
    Cette interface est une spécialisation de l'interface fonctionnelle "Function" en spécifiant le type du parameter "t" a "int" et en spécifiant la valeur de retour a "double".
    
    
  • LongToIntFunction: int applyAsInt(long t)
    Cette interface est une spécialisation de l'interface fonctionnelle "Function" en spécifiant le type du parameter "t" a "long" et en spécifiant la valeur de retour a "long".
    
    
  • LongToDoubleFunction: double applyAsDouble(long t)
    Cette interface est une spécialisation de l'interface fonctionnelle "Function" en spécifiant le type du parameter "t" a "long" et en spécifiant la valeur de retour a "double".
    
    
  • DoubleToIntFunction: int applyAsInt(double t)
    Cette interface est une spécialisation de l'interface fonctionnelle "Function" en spécifiant le type du parameter "t" a "double" et en spécifiant la valeur de retour a "int".
    
    
  • DoubleToLongFunction: long applyAsLong(double t)
    Cette interface est une spécialisation de l'interface fonctionnelle "Function" en spécifiant le type du parameter "t" a "double" et en spécifiant la valeur de retour a "long".
    
  
  
• BiFunction<T, U, R>: R apply(T t, U u)
  Cette interface définit une méthode fonctionnelle "R apply(T t, U u)" qui declare deux paramètres ("t" de type "T", "u" de type "U") et retourne une valeur de type "R".
  L'implementation doit, typiquement, appliquer une logique autour de la valeur des arguments "t" et "u".
  BiFunction<Integer, Integer, String> valueOfMax = (a, b) -> "id-".concat(String.valueOf(Math.max(a, b))); System.out.println(valueOfMax.apply(1, 2));
  
  • ToIntBiFunction<T, U>: int applyAsInt(T t, U u)
    Cette interface est une spécialisation de l'interface fonctionnelle "BiFunction" en spécifiant la valeur de retour a "int".
    
    
  • ToLongBiFunction<T, U>: long applyAsLong(T t, U u)
    Cette interface est une spécialisation de l'interface fonctionnelle "BiFunction" en spécifiant la valeur de retour a "long".
    
    
  • ToDoubleBiFunction<T, U>: double applyAsDouble(T t, U u)
    Cette interface est une spécialisation de l'interface fonctionnelle "BiFunction" en spécifiant la valeur de retour a "double".
    
  
  
• UnaryOperator<T> extends Function<T, T>: T apply(T t)
  Cette interface est une spécialisation de l'interface fonctionnelle "Function" en spécifiant le type du parameter "t" et la valeur de retour au meme type "T".
  UnaryOperator<Integer> abs = t -> Math.abs(t); System.out.println(abs.apply(-1));
  
  • IntUnaryOperator: int applyAsInt(int t)
    Cette interface est une spécialisation de l'interface fonctionnelle "Function" en spécifiant le type du parameter "t" et la valeur de retour au meme type "int".
    
    
  • LongUnaryOperator: long applyAsLong(long t)
    Cette interface est une spécialisation de l'interface fonctionnelle "Function" en spécifiant le type du parameter "t" et la valeur de retour au meme type "long".
    
    
  • DoubleUnaryOperator: double applyAsDouble(double t)
    Cette interface est une spécialisation de l'interface fonctionnelle "Function" en spécifiant le type du parameter "t" et la valeur de retour au meme type "double".
    
  
  
• BinaryOperator<T> extends BiFunction<T, T, T>: T apply(T t, T u)
  Cette interface est une spécialisation de l'interface fonctionnelle "BiFunction" en spécifiant le type des parameters "t" et "u" et la valeur de retour au meme type "T".
  BinaryOperator<Integer> add = (a, b) -> a + b; System.out.println(add.apply(3, 4));
  
  • IntBinaryOperator: int applyAsInt(int t, int u)
    Cette interface est une spécialisation de l'interface fonctionnelle "BiFunction" en spécifiant le type des parameters "t" et "u" et la valeur de retour au meme type "int".
    
    
  • LongBinaryOperator: long applyAsLong(long t, long u)
    Cette interface est une spécialisation de l'interface fonctionnelle "BiFunction" en spécifiant le type des parameters "t" et "u" et la valeur de retour au meme type "long".
    
    
  • DoubleBinaryOperator: double applyAsDouble(double t, double u)
    Cette interface est une spécialisation de l'interface fonctionnelle "BiFunction" en spécifiant le type des parameters "t" et "u" et la valeur de retour au meme type "double".
    

Il est possible de specifier le type d'une interface fonctionnelle en étant le type du paramètre ou la valeur de retour d'une méthode.

Par exemple une méthode peut être définit comme suit:
MyFunctionalInterface foo(FunctionalInterface myFunctionalInterface) { ... }

Pour invoquer une méthode qui declare un paramètre ou une valeur de retour dont le type est une interface fonctionnelle, il est possible d'utiliser:

• Une reference vers une méthode statique: MyType::MyStaticMethod
  public class TestFunctionalInterface { public static String toLowerCase(String value) { return value == null ? "" : value.toLowerCase(); } public static String convert(String value, UnaryOperator<String> myStringConverter) { return myStringConverter.apply(value); } public static void main(String[] args) { final String convertedValue = TestFunctionalInterface.convert("tESt", TestFunctionalInterface::toLowerCase); System.out.println(convertedValue); } }
  
• Une reference vers une méthode d'instance: myInstance::MyInstanceMethod
  public class TestFunctionalInterface { public String toUpperCase(String value) { return value == null ? "" : value.toUpperCase(); } public static String convert(String value, UnaryOperator<String> myStringConverter) { return myStringConverter.apply(value); } public static void main(String[] args) { final TestFunctionalInterface testFunctionalInterface = new TestFunctionalInterface(); final String convertedValue = TestFunctionalInterface.convert("tESt", testFunctionalInterface::toUpperCase); System.out.println(convertedValue); } }
  
• Une reference vers une méthode d'instance d'un objet arbitraire d'un type particulier : MyType::MyInstanceMethod
  Notez que cette notation implique que l’interface fonctionnelle doit accepter un paramètre de type "MyType" :
  
  • Dans l'exemple ci-dessous, la référence "String::toUpperCase" implique que l’interface fonctionnelle est de type "Function<String, String>".
    On peut utiliser une instruction d'affectation pour illustrer cette impliquation :
    Function<String, String> toUpperCaseFunction = String::toUpperCase;
    
  • Par contre, la reference "TestFunctionalInterface::toUpperCase" implique que l’interface fonctionnelle est de type "Function<TestFunctionalInterface, String>".
    On peut utiliser une instruction d'affectation pour illustrer cette impliquation :
    Function<TestFunctionalInterface, String> toUpperCaseFunction = TestFunctionalInterface::toUpperCase;
    
  public class TestFunctionalInterface { private String value; public TestFunctionalInterface(String value) { this.value = value; } public String toUpperCase() { return value == null ? "" : value.toUpperCase(); } public static List<String> convert(String[] values, UnaryOperator<String> myStringConverter) { final List<String> convertedvalues = new ArrayList<>(); Arrays.asList(values).forEach(v -> convertedvalues.add(myStringConverter.apply(v))); return convertedvalues; } public static List<String> convert(TestFunctionalInterface[] values, Function<TestFunctionalInterface, String> myFunction) { final List<String> convertedvalues = new ArrayList<>(); Arrays.asList(values).forEach(v -> convertedvalues.add(myFunction.apply(v))); return convertedvalues; } public static void main(String[] args) { //first example: String::toUpperCase { String[] values = { "abc", "XYz" }; final List<String> convertedValues = TestFunctionalInterface.convert(values, String::toUpperCase); System.out.println(convertedValues); } //second example: TestFunctionalInterface::toUpperCase { TestFunctionalInterface[] values = { new TestFunctionalInterface("abc"), new TestFunctionalInterface("XYz") }; final List<String> convertedValues = TestFunctionalInterface.convert(values, TestFunctionalInterface::toUpperCase); System.out.println(convertedValues); } } }
  
• Une reference vers un constructeur: MyType::new
  public class TestFunctionalInterface { private String value; public TestFunctionalInterface(String value) { this.value = value; } public String getValue() { return value; } public static TestFunctionalInterface build(String value, Function<String, TestFunctionalInterface> myFunction) { return myFunction.apply(value); } public static void main(String[] args) { TestFunctionalInterface testFunctionalInterface = TestFunctionalInterface.build("test", TestFunctionalInterface::new); final String convertedValue = testFunctionalInterface.getValue(); System.out.println(convertedValue); } }
  
• Utiliser une expression lambda: (t -> t)
  public class TestFunctionalInterface { public static String convert(String value, UnaryOperator<String> myStringConverter) { return myStringConverter.apply(value); } public static void main(String[] args) { final String convertedValue = TestFunctionalInterface.convert(" test ", (t -> t == null ? "" : t.trim())); System.out.println(convertedValue); } }