Java | Interfaces fonctionnelles
  1. Interfaces fonctionnelles
  2. Package "java.util.function"
  3. Utiliser une interface fonctionnelle comme paramètre d'une methode
  1. Interfaces fonctionnelles
    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);
    }
}
  2. Package "java.util.function"
    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));

    • 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");

    • 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");

    • 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());

    • 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".




    • 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));

    • 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));

    • 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));
  3. Utiliser une interface fonctionnelle comme paramètre d'une methode
    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" (s -> s.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; // s -> s.toUpperCase

      • Par contre, la reference "TestFunctionalInterface::toUpperCase" (t -> t.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; // t -> t.toUpperCase

      public class TestFunctionalInterface {
    private String value;

    public TestFunctionalInterface(String value) {
        this.value = value;
    }

    public String toUpperCase() {
        return value == null ? "" : value.toUpperCase();
    }

    public static void convert(String value, UnaryOperator<String> myStringConverter) {
        System.out.println(myStringConverter.apply(value));
    }

    public static void convert(TestFunctionalInterface object, Function<TestFunctionalInterface, String> myFunction) {
        System.out.println(myFunction.apply(object));
    }

    public static void main(String[] args) {
        // first example: String::toUpperCase
        TestFunctionalInterface.convert("hello", String::toUpperCase);

        // second example: TestFunctionalInterface::toUpperCase
        TestFunctionalInterface.convert(new TestFunctionalInterface("hello"), TestFunctionalInterface::toUpperCase);
    }
}
    • Une reference vers un constructeur: MyType::new
      public class TestFunctionalInterface {
    public TestFunctionalInterface(String value) {
        System.out.println(value);
    }

    public static TestFunctionalInterface build(String value, Function<String, TestFunctionalInterface> myFunction) {
        return myFunction.apply(value);
    }

    public static void main(String[] args) {
        TestFunctionalInterface.build("test", TestFunctionalInterface::new);
    }
}
    • 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);
    }
}
© 2025  mtitek