La interfaz BiFunction es parte del paquete java.util.function que se introdujo desde Java 8 para implementar la programación funcional en Java. Representa una función que toma dos argumentos y produce un resultado. De ahí esta interfaz funcional que toma en 3 parámetros a saber: –
- T : denota el tipo del primer argumento de la función
- U : denota el tipo del segundo argumento de la función
- R : denota el tipo de retorno de la función
La expresión lambda asignada a un objeto de tipo BiFunction se usa para definir su apply() que eventualmente aplica la función dada en los argumentos. La principal ventaja de usar una BiFunción es que nos permite usar 2 argumentos de entrada mientras que en función solo podemos tener 1 argumento de entrada.
Funciones en la interfaz BiFunction
La interfaz BiFunction consta de las siguientes dos funciones:
1. aplicar()
Este método aplica la función dada a los argumentos.
Sintaxis:
R apply(T t, U u)
Parámetros: Este método toma dos parámetros:
- t – el primer argumento de la función
- u – el segundo argumento de la función
Devoluciones: este método devuelve el resultado de la función que es de tipo R. A continuación se muestra el código para ilustrar el método apply():
Programa 1:
Java
// Java Program to demonstrate
// BiFunction's apply() method
import java.util.function.BiFunction;
public class Main {
public static void main(String args[])
{
// BiFunction to add 2 numbers
BiFunction<Integer, Integer, Integer> add = (a, b) -> a + b;
// Implement add using apply()
System.out.println("Sum = " + add.apply(2, 3));
// BiFunction to multiply 2 numbers
BiFunction<Integer, Integer, Integer> multiply = (a, b) -> a * b;
// Implement add using apply()
System.out.println("Product = " + multiply.apply(2, 3));
}
}
Sum = 5 Product = 6
2. agregarLuego()
Devuelve una función compuesta en la que la función parametrizada se ejecutará después de la primera. Si la evaluación de cualquiera de las funciones arroja un error, se transmite al llamador de la función compuesta. Nota: La función que se pasa como argumento debe ser de tipo Function y no BiFunction.
Sintaxis:
default <V>
BiFunction<T, U, V>
addThen(Function<? super R, ? extends V> after)
donde V es el tipo de salida de la función posterior y de la función compuesta
Parámetros: este método acepta un parámetro después del cual es la función que se aplicará después de que esta función sea uno.
Valor devuelto: este método devuelve una función compuesta que primero aplica la función actual primero y luego la función posterior.
Excepción: este método arroja NullPointerException si la función posterior es nula.
A continuación se muestra el código para ilustrar el método addThen():
Programa 1:
Java
// Java Program to demonstrate
// BiFunction's addThen() method
import java.util.function.BiFunction;
public class Main {
public static void main(String args[])
{
// BiFunction to demonstrate composite functions
// Here it will find the sum of two integers
// and then return twice their sum
BiFunction<Integer, Integer, Integer> composite1 = (a, b) -> a + b;
// Using addThen() method
composite1 = composite1.addThen(a -> 2 * a);
// Printing the results
System.out.println("Composite1 = " + composite1.apply(2, 3));
// BiFunction to demonstrate composite functions
// Here it will find the sum of two integers
// and then return twice their sum
BiFunction<Integer, Integer, Integer> composite2 = (a, b) -> a * b;
// Using addThen() method
composite2 = composite2.addThen(a -> 3 * a);
// Printing the result
System.out.println("Composite2 = " + composite2.apply(2, 3));
}
}
Composite1 = 10 Composite2 = 18
Programa 2: para demostrar cuándo se devuelve NullPointerException.
Java
// Java Program to demonstrate
// BiFunction's addThen() method
import java.util.function.BiFunction;
public class Main {
public static void main(String args[])
{
// BiFunction which finds the sum of 2 integers
// and returns twice their sum
BiFunction<Integer, Integer, Integer> composite = (a, b) -> a + b;
try {
// Using addThen() method
composite = composite.addThen(null);
// Printing the result
System.out.println("Composite = " + composite.apply(2, 3));
}
catch (Exception e) {
System.out.println("Exception: " + e);
}
}
}
Exception: java.lang.NullPointerException
Programa 3: para demostrar cómo se devuelve y se maneja una excepción en la función posterior.
En el siguiente programa, cuando (2, 3) se pasa como parámetro a la primera función, devuelve la suma 5. Ahora esta suma se pasará como parámetro a la función posterior, es decir, al método addThen(). Aquí, pasar 5 a después de la función da como resultado (5 – 5 = 0), es decir, el denominador se convertirá en 0. Por lo tanto, se lanzará ArithmeticException. Esta excepción se manejará en la función apply(), en lugar de la función addThen().
Java
// Java Program to demonstrate
// BiFunction's addThen() method
import java.util.function.BiFunction;
public class Main {
public static void main(String args[])
{
// BiFunction which finds the sum of 2 integers
// and returns twice their sum
BiFunction<Integer, Integer, Integer> composite = (a, b) -> a + b;
// Using addThen() method
composite = composite.addThen(a -> a / (a - 5));
try {
// Printing the result using apply()
System.out.println("Composite = " + composite.apply(2, 3));
}
catch (Exception e) {
System.out.println("Exception: " + e);
}
}
}
Exception: java.lang.ArithmeticException: / by zero
Nota:
- No es posible agregar una BiFunción a una BiFunción existente usando addThen().
- La interfaz BiFunction es útil cuando se necesita pasar 2 parámetros, a diferencia de la interfaz Function que permite pasar solo uno. Sin embargo, es posible poner en cascada dos o más objetos Función para formar una BiFunción, pero en ese caso no será posible usar ambos parámetros al mismo tiempo. Esta es la utilidad de BiFunction.
- La expresión Lambda se utiliza para inicializar el método apply() en la interfaz BiFunction.