Java 8 BiConsumer | Examples of BiConsumer accept and andThen methods

A quick guide to BiConsumer functional interface in java 8 to take two inputs and return one object.Program to run the two BiConsumers one after other

BiConsumer is a functional interface which is part of java.util.function widely used with collection api.

Package java.util.function is introduced in Java 8.

BiConsumer has two methods in it.

1) void accept(T t, U u)
2) BiConsumer<T,U>     andThen(BiConsumer<? super T,? super U> after)

accept() method is an abstract method and andThen() is a default method.

In this post, we will see how to use BiConsumer interface with examples. Please post your quires in the comment section.

Accept() method:

Syntax:

void accept(T t, U u)

t --> the first argument input type
u --> the second argument input type

BiConsumer does not return any value. It just perform some operation inside accept method.

Example to find the size of two lists are same or not.

package org.java.biconsumer.examples;

import java.util.ArrayList;
import java.util.List;
import java.util.function.BiConsumer;

public class BiConsumerExample {

 public static void main(String[] args) {

  List<String> fruits = new ArrayList<>();
  fruits.add("apple");
  fruits.add("banana");
  fruits.add("orange");

  List<String> colors = new ArrayList<>();
  fruits.add("Red");
  fruits.add("yello");
  fruits.add("orange");

  BiConsumer<List<String>, List<String>> same = (fruitsNames, fruitColors) -> {
   if (fruitColors.size() != fruitColors.size()) {
    System.out.println("fruits names and colors count is same");
   }else{
    System.out.println("fruits names and colors count is not same");
   }
  };

  same.accept(fruits, colors);
 }

}

Output:

fruits names and colors count is same

Example to iterate the Map:

Another way to understand how BiConsumer can be used in a simple way using Map and printing its key, value paris.

package org.java.biconsumer.examples;

import java.util.HashMap;
import java.util.Map;
import java.util.function.BiConsumer;

public class MapIteration {

 public static void main(String[] args) {

  Map<Integer, String> values = new HashMap<>();
  values.put(1, "One");
  values.put(2, "Two");
  values.put(3, "Three");

  BiConsumer<Integer, String> mapConsumer = (key, value) -> {
   System.out.println("Key : " + key + " , Value : " + value);
   values.put(4, "Four");
  };

  values.forEach(mapConsumer);
 }

}

Output:

Key : 1 , Value : One
Key : 2 , Value : Two
Key : 3 , Value : Three

Just uncomment the line values.put(4, "Four"); in biconsumer logic then will 

through ConcurrentModificationException.

Exception in thread "main" java.util.ConcurrentModificationException
 at java.util.HashMap.forEach(Unknown Source)
 at org.java.biconsumer.examples.MapIteration.main(MapIteration.java:21)

Concatenating two strings:

Takes two strings input and concatenate them into a single string. Hello World example using BiConsumer.

package org.java.biconsumer.examples;

import java.util.function.BiConsumer;

public class ConcatnateStrings {
 public static void main(String[] args) {
  
  BiConsumer<String, String> concatenateBiConsumer = (value1, value2) -> {
   System.out.println(value1+" "+value2);
  };
  
  concatenateBiConsumer.accept("Hello", "World");
 }
}

Output:

 

Hello World

andThen() method:

This methods is used to run the two biconsumer logic's one after another on the same inputs. Need to pass second bicosumer instances as the the parameter.

Syntax:

BiConsumer<T,U> andThen(BiConsumer<? super T,? super U> after)

package org.java.biconsumer.examples;

import java.util.ArrayList;
import java.util.List;
import java.util.function.BiConsumer;

public class AndThenExample {

 public static void main(String[] args) {

  List<String> fruits = new ArrayList<>();
  fruits.add("apple");
  fruits.add("banana");
  fruits.add("orange");

  List<String> colors = new ArrayList<>();
  fruits.add("Red");
  fruits.add("yello");

  BiConsumer<List<String>, List<String>> first = (fruitsNames, fruitColors) -> {
   if (fruitsNames.size() != fruitColors.size()) {
    System.out.println("fruits names and colors count is same");
   } else {
    System.out.println("fruits names and colors count is not same");
   }
  };

  BiConsumer<List<String>, List<String>> second = (fruitsNames1, fruitColors2) -> {
   fruitsNames1.stream().forEach(value -> System.out.println(value));
   fruitColors2.stream().forEach(value -> System.out.println(value));

  };

  first.andThen(second).accept(fruits, colors);
 }
}

Output:

fruits names and colors count is same
Fruit Names: 
apple 
banana 
orange 
Red 
yello 
Fruit Colors: 

In the above example created two BiConsumer instances and intended to run one by one using andThen method. 

If we are passing null to andThem() method, will through NullPointerException.

Code snipper:  first.andThen(null).accept(fruits, colors);

Post your questions in comments section.