Interface BiFunction en Java

1. Exemple de méthode BiFunction apply() en Java
2. Méthode BiFunction andThen() en Java
3. Éviter NullPointerException dans l’interface BiFunction
4. BiFonction avec HashMap en Java
5. BiFunction et référence de méthode
6. Conclusion

Dans ce didacticiel, nous aborderons l’interface BiFunction en Java.

L’interface BiFunction est une interface fonctionnelle intégrée introduite dans Java 8 et se trouve dans le package java.util.function. Contrairement à l’interface Function qui prend deux génériques (un type d’argument et un type de retour), BiFunction prend deux arguments et produit un résultat.

Nous pouvons attribuer une expression lambda ou une référence de méthode qui prend deux arguments et renvoie un résultat à un objet de type BiFunction.

BiFunction prend trois génériques - T, U et R. T et U sont les types des premier et deuxième arguments, respectivement. R est le type du résultat de la fonction.

interface BiFunction<T, U, R>

L’interface BiFunction a deux méthodes :

• apply() : il effectue l’opération définie sur les arguments et renvoie un résultat. La syntaxe de cette méthode est :

R apply(T t, U u) // R is the return type. T and U are the types of the two arguments

• andThen() : Il renvoie le résultat d’une fonction composée. En termes plus simples, il exécute d’abord la BiFonction sur les deux arguments et produit un résultat. Ensuite, il passe le résultat à une fonction. La syntaxe de cette méthode est :

default<V> BiFunction<T, U, V> andThen(Function<? super R, ? extends V> after)

Exemple de méthode BiFunction apply() en Java

Créons une BiFonction simple qui prend des arguments de type Integer et Double et renvoie une chaîne. Nous avons utilisé la méthode apply() pour passer l’argument et obtenir le résultat.

Voir l’exemple ci-dessous.

import java.util.function.*;

public class SimpleTesting {
  public static void main(String args[]) {
    // BiFunction with arguments of type Integer and Double
    // and return type of String
    BiFunction<Integer, Double, String> biFunction = (a, b) -> {
      double result = a * b;
      String s = "The result from the BiFunction is: " + result;
      return s;
    };

    String output = biFunction.apply(10, 15.5);
    System.out.print(output);
  }
}

Production :

The result from the BiFunction is: 155.0

Méthode BiFunction andThen() en Java

Passons le résultat de la BiFonction définie ci-dessus à une Fonction. Nous utiliserons la méthode andThen(). Cette méthode évalue d’abord le résultat de la fonction BiFunction, puis transmet ce résultat à la fonction after.

import java.util.function.*;

public class SimpleTesting {
  public static void main(String args[]) {
    // BiFunction with arguments of type Integer and Double
    // and return type of String
    BiFunction<Integer, Double, String> biFunction = (a, b) -> {
      double result = a * b;
      String s = "The result from the BiFunction is: " + result;
      return s;
    };

    // Function with argument of type String
    // and return type of Integer
    Function<String, Integer> after = s -> {
      Integer length = s.length();
      return length;
    };

    int output = biFunction.andThen(after).apply(
        10, 15.5); // first evaluates the BiFunction and then the Function
    System.out.print(output);
  }
}

Production :

40

Éviter NullPointerException dans l’interface BiFunction

Si nous passons une référence nulle à la méthode andThen(), le code renvoie NullPointerException. Voir l’exemple ci-dessous. Nous devrions éviter de telles erreurs et toujours placer le code dans des blocs try...catch.

import java.util.function.*;

public class SimpleTesting {
  public static void main(String args[]) {
    BiFunction<Integer, Double, String> biFunction = (a, b) -> {
      double result = a * b;
      String s = "The result from the BiFunction is: " + result;
      return s;
    };

    Function<String, Integer> after = null;

    int output = biFunction.andThen(after).apply(10, 15.5);
    System.out.print(output);
  }
}

Production :

Exception in thread "main" java.lang.NullPointerException
	at java.base/java.util.Objects.requireNonNull(Objects.java:222)
	at java.base/java.util.function.BiFunction.andThen(BiFunction.java:69)
	at SimpleTesting.main(SimpleTesting.java:15)

Notez qu’on ne peut pas intégrer deux BiFonctions en utilisant la méthode andThen().

BiFonction avec HashMap en Java

Les BiFunctions sont utilisées comme arguments dans quelques méthodes HashMap comme compute(), computeIfPresent(), merge() et replaceAll().

Créons un exemple pour utiliser BiFunction dans HashMap. Considérez un HashMap qui stocke les numéros de liste des étudiants et leurs scores. Nous devons ajouter 5 au score de chaque élève, à l’exception du numéro de rôle 101.

import java.util.HashMap;
import java.util.function.*;

public class SimpleTesting {
  public static void main(String args[]) {
    HashMap<Integer, Double> scoreMap = new HashMap<>();
    scoreMap.put(101, 95.2);
    scoreMap.put(102, 86.0);
    scoreMap.put(103, 91.9);
    scoreMap.put(104, 72.8);
    scoreMap.put(105, 89.5);

    System.out.println("Intial HashMap: " + scoreMap);

    // BiFunction with arguments of type Integer and Double
    // and return type of Double
    BiFunction<Integer, Double, Double> biFunction = (key, value) -> {
      if (key == 101)
        return value;
      else
        return value + 5;
    };
    scoreMap.replaceAll(biFunction);
    System.out.print("HashMap After The Update: " + scoreMap);
  }
}

Production :

Intial HashMap: {101=95.2, 102=86.0, 103=91.9, 104=72.8, 105=89.5}
HashMap After The Update: {101=95.2, 102=91.0, 103=96.9, 104=77.8, 105=94.5}

BiFunction et référence de méthode

Jusqu’à présent, nous avons utilisé l’interface BiFunction comme référence pour les expressions lambda. Une méthode peut également être référencée à l’aide d’une BiFonction. La méthode ne doit prendre que deux arguments et renvoie un résultat.

Écrivons une méthode statique simple qui vérifie si la somme des deux entiers donnés est paire ou non. Nous pouvons attribuer cette référence de méthode à une BiFunction. Voir l’exemple ci-dessous.

import java.util.function.*;

public class SimpleTesting {
  static boolean isSumEven(int a, int b) {
    int sum = a + b;
    if (sum % 2 == 0)
      return true;
    else
      return false;
  }

  public static void main(String args[]) {
    BiFunction<Integer, Integer, Boolean> biFunction = SimpleTesting::isSumEven;

    System.out.println("Is sum of 10 and 21 even? " + biFunction.apply(10, 21));
    System.out.print("Is sum of 5 and 7 even? " + biFunction.apply(5, 7));
  }
}

Production :

Is sum of 10 and 21 even? false
Is sum of 5 and 7 even? true

Conclusion

L’interface Java BiFunction est une interface fonctionnelle. Il est utilisé comme cible d’affectation pour les expressions lambda ou les références de méthode. L’interface BiFunction est préférée à l’interface Function lorsque nous devons passer deux arguments.

L’interface BiFunction contient deux méthodes : apply() et andThen(). La méthode apply() applique la fonction sur les deux arguments donnés. La méthode andThen() est utilisée pour passer le résultat de BiFunction à une interface Function.