Interfaz BiFunction en Java

  2. HowTo
  3. Howtos de Java
  4. Interfaz BiFunction en Java
Mohammad Irfan 12 octubre 2023
Java Java Stream Java BiFunction Java Interface
  1. Ejemplo del método BiFunction apply() en Java
  2. Método BiFunction andThen() en Java
  3. Evite NullPointerException en la interfaz BiFunction
  4. BiFunción con HashMap en Java
  5. Referencia de métodos y bifunciones
  6. Conclusión
Interfaz BiFunction en Java

En este tutorial, discutiremos la interfaz BiFunction en Java.

La interfaz BiFunction es una interfaz funcional incorporada introducida en Java 8 y se encuentra en el paquete java.util.function. A diferencia de la interfaz Function que toma dos genéricos (un tipo de argumento y un tipo de retorno), BiFunction toma dos argumentos y produce un resultado.

Podemos asignar una expresión lambda o una referencia de método que tome dos argumentos y devuelva un resultado a un objeto de tipo BiFunction.

BiFunction toma tres genéricos: T, U y R. T y U son los tipos del primer y segundo argumento, respectivamente. R es el tipo del resultado de la Función.

interface BiFunction<T, U, R>

La interfaz BiFunction tiene dos métodos:

  • apply(): Realiza la operación definida sobre los argumentos y devuelve un resultado. La sintaxis de este método es:
R apply(T t, U u) // R is the return type. T and U are the types of the two arguments
  • andThen(): Devuelve el resultado de una función compuesta. En palabras más simples, primero ejecuta BiFunction en los dos argumentos y produce un resultado. A continuación, pasa el resultado a una Función. La sintaxis de este método es:
default<V> BiFunction<T, U, V> andThen(Function<? super R, ? extends V> after)

Ejemplo del método BiFunction apply() en Java

Vamos a crear una BiFunción simple que tome argumentos de tipo Entero y Doble y devuelva una Cadena. Usamos el método apply() para pasar el argumento y obtener el resultado.

Vea el ejemplo a continuación.

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

Producción :

The result from the BiFunction is: 155.0

Método BiFunction andThen() en Java

Pasemos el resultado de la BiFunción definida arriba a una Función. Usaremos el método andThen(). Este método primero evalúa el resultado de BiFunction y luego pasa ese resultado a la función 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);
  }
}

Producción :

40

Evite NullPointerException en la interfaz BiFunction

Si pasamos una referencia nula al método andThen(), el código devuelve NullPointerException. Vea el ejemplo a continuación. Deberíamos evitar tales errores y siempre poner el código en bloques 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);
  }
}

Producción :

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)

Tenga en cuenta que no podemos integrar dos BiFunctions utilizando el método andThen().

BiFunción con HashMap en Java

BiFunctions se utilizan como argumentos en algunos métodos HashMap como compute(), computeIfPresent(), merge() y replaceAll().

Creemos un ejemplo para usar BiFunction en HashMap. Considere un HashMap que almacene los números de lista de los estudiantes y sus puntajes. Necesitamos sumar 5 al puntaje de cada estudiante, excepto el número de rollo 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);
  }
}

Producción :

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}

Referencia de métodos y bifunciones

Hasta ahora, hemos utilizado la interfaz BiFunction como referencia para las expresiones lambda. También se puede hacer referencia a un método usando una BiFunction. El método debe tomar solo dos argumentos y devolver un resultado.

Escribamos un método estático simple que verifique si la suma de los dos enteros dados es par o no. Podemos asignar esta referencia de método a una BiFunción. Vea el ejemplo a continuación.

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

Producción :

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

Conclusión

La interfaz Java BiFunction es una interfaz funcional. Se utiliza como destino de asignación para expresiones lambda o referencias de métodos. Se prefiere la interfaz BiFunction sobre la interfaz Function cuando necesitamos pasar dos argumentos.

La interfaz BiFunction contiene dos métodos: apply() y andThen(). El método apply() aplica la función en los dos argumentos dados. El método andThen() se utiliza para pasar el resultado de BiFunction a una interfaz de función.

Artículo relacionado - Java Stream

Artículo relacionado - Java Interface