• Home
  • Docker
  • Kubernetes
  • LLMs
  • Java
  • Ubuntu
  • Maven
  • Big Data
  • Archived
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
  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".

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

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

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

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

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



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

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

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

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

    • Une reference vers une méthode d'instance: myInstance::MyInstanceMethod

    • 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 :

      • 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 :


    • Une reference vers un constructeur: MyType::new

    • Utiliser une expression lambda: (t -> t)
© 2025  mtitek