La interfaz BiConsumer 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. Sin embargo, este tipo de funciones no devuelve ningún valor.
Esta interfaz funcional admite dos genéricos, a saber: –
- T : denota el tipo del primer argumento de entrada a la operación
- U : denota el tipo del segundo argumento de entrada a la operación
La expresión lambda asignada a un objeto de tipo BiConsumer se usa para definir su accept() que eventualmente aplica la operación dada a sus argumentos.
Los BiConsumers son útiles cuando no se requiere devolver ningún valor, ya que se espera que operen a través de efectos secundarios.
Funciones en la interfaz BiConsumer
La interfaz de BiConsumer consta de las siguientes dos funciones:
1. aceptar()
Este método acepta dos valores y realiza la operación en los argumentos dados
Sintaxis:
void accept(T t, U u)
Parámetros: Este método toma dos parámetros:
- t – el primer argumento de entrada
- u – el segundo argumento de entrada
Devoluciones: este método no devuelve ningún valor.
A continuación se muestra el código para ilustrar el método accept():
Programa 1: Programa para comparar 2 listas de enteros usando el método accept() de BiConsumer:
Java
// Java Program to demonstrate
// BiConsumer's accept() method
import java.util.ArrayList;
import java.util.List;
import java.util.function.BiConsumer;
public class GFG {
public static void main(String args[])
{
// Create the first list
List<Integer> lista = new ArrayList<Integer>();
lista.add(2);
lista.add(1);
lista.add(3);
// Create the second list
List<Integer> listb = new ArrayList<Integer>();
listb.add(2);
listb.add(1);
listb.add(2);
// BiConsumer to compare both lists
BiConsumer<List<Integer>, List<Integer> >
equals = (list1, list2) ->
{
if (list1.size() != list2.size()) {
System.out.println("False");
}
else {
for (int i = 0; i < list1.size(); i++)
if (list1.get(i) != list2.get(i)) {
System.out.println("False");
return;
}
System.out.println("True");
}
};
equals.accept(lista, listb);
}
}
False
2. y entonces()
Devuelve un BiConsumer compuesto donde el BiConsumer parametrizado se ejecutará después del primero. Si la evaluación de cualquiera de las operaciones arroja un error, se transmite al llamador de la operación compuesta.
Nota: La operación que se pasa como argumento debe ser del tipo BiConsumer.
Sintaxis:
default BiConsumer <T, U>
andThen(BiConsumer<? super T, ? super U> after)
Parámetros: Este método acepta un parámetro tras el cual se encuentra el BiConsumer a aplicar tras el actual.
Valor devuelto: este método devuelve un BiConsumer compuesto que primero aplica la operación actual primero y luego la operación posterior.
Excepción: este método arroja NullPointerException si la operación posterior es nula.
A continuación se muestra el código para ilustrar el método andThen():
Programa 1:
Java
// Java Program to demonstrate
// BiConsumer's andThen() method
import java.util.ArrayList;
import java.util.List;
import java.util.function.BiConsumer;
public class Main {
public static void main(String args[])
{
// Create first list
List<Integer> lista = new ArrayList<Integer>();
lista.add(2);
lista.add(1);
lista.add(3);
// Create second list
List<Integer> listb = new ArrayList<Integer>();
listb.add(2);
listb.add(1);
listb.add(2);
// BiConsumer to compare 2 lists of integers
BiConsumer<List<Integer>, List<Integer> > equals = (list1, list2) ->
{
if (list1.size() != list2.size()) {
System.out.println("False");
}
else {
for (int i = 0; i < list1.size(); i++)
if (list1.get(i) != list2.get(i)) {
System.out.println("False");
return;
}
System.out.println("True");
}
};
// BiConsumer to print 2 lists
BiConsumer<List<Integer>, List<Integer> > disp = (list1, list2) ->
{
list1.stream().forEach(a -> System.out.print(a + " "));
System.out.println();
list2.stream().forEach(a -> System.out.print(a + " "));
System.out.println();
};
// Using addThen() method
equals.andThen(disp).accept(lista, listb);
}
}
False 2 1 3 2 1 2
Programa 2: para demostrar cuándo se devuelve NullPointerException .
Java
// Java Program to demonstrate
// BiConsumer's andThen() method
import java.util.ArrayList;
import java.util.List;
import java.util.function.BiConsumer;
public class Main {
public static void main(String args[])
{
// Create first list
List<Integer> lista = new ArrayList<Integer>();
lista.add(2);
lista.add(1);
lista.add(3);
// Create second list
List<Integer> listb = new ArrayList<Integer>();
listb.add(2);
listb.add(1);
listb.add(2);
// BiConsumer to compare 2 lists of integers
BiConsumer<List<Integer>, List<Integer> > equals = (list1, list2) ->
{
if (list1.size() != list2.size()) {
System.out.println("False");
}
else {
for (int i = 0; i < list1.size(); i++)
if (list1.get(i) != list2.get(i)) {
System.out.println("False");
return;
}
System.out.println("True");
}
};
// BiConsumer to print 2 lists
BiConsumer<List<Integer>, List<Integer> > disp = (list1, list2) ->
{
list1.stream().forEach(a -> System.out.print(a + " "));
System.out.println();
list2.stream().forEach(a -> System.out.print(a + " "));
System.out.println();
};
try {
equals.andThen(null).accept(lista, listb);
}
catch (Exception e) {
System.out.println("Exception : " + e);
}
}
}
Exception : java.lang.NullPointerException
Programa 3: para demostrar cómo se devuelve y maneja una excepción después de la función.
Java
// Java Program to demonstrate
// BiConsumer's andThen() method
import java.util.ArrayList;
import java.util.List;
import java.util.function.BiConsumer;
public class Main {
public static void main(String args[])
{
// Create first list
List<Integer> lista = new ArrayList<Integer>();
lista.add(2);
lista.add(1);
lista.add(3);
// Create second list
List<Integer> listb = new ArrayList<Integer>();
listb.add(2);
listb.add(1);
// BiConsumer to compare 2 lists of integers
BiConsumer<List<Integer>, List<Integer> > equals = (list1, list2) ->
{
for (int i = 0; i < list1.size(); i++)
if (list1.get(i) != list2.get(i)) {
System.out.println("False");
return;
}
System.out.println("True");
};
// BiConsumer to print 2 lists
BiConsumer<List<Integer>, List<Integer> > disp = (list1, list2) ->
{
list1.stream().forEach(a -> System.out.print(a + " "));
System.out.println();
list2.stream().forEach(a -> System.out.print(a + " "));
System.out.println();
};
try {
disp.andThen(equals).accept(lista, listb);
}
catch (Exception e) {
System.out.println("Exception : " + e);
}
}
}
2 1 3 2 1 Exception : java.lang.IndexOutOfBoundsException: Index 2 out of bounds for length 2