Consumer and Biconsumer In Java 8 | accept and andThen() method

What is Consumer and BiConsumer in Java?

Consumer in Java

Consumer is Functional Interface which takes arguments only and return nothing.

Consumer is Interface in Java Programming language which introduced in Java 8 and it is part of java.util.function.

As a name suggest, it only consumes not return anything. means it consumes value and perform required operations.

@FunctionalInterface
public interface Consumer<T> {
  void accept(T t);
}

Consumer only contains two methods : one is abstract and another is default.

1. void accept (T t) 
2. default Consumer<T> andThen(Consumer<? super T> after)
   

You can see return type of accept method is void means it does not return anything.

Consumer can be used in all contexts where an object needs to be consumed, Like taken as input, and some operation is to be performed on the object without returning any result.

Since Consumer is a functional interface, hence it can be used as the assignment target for a lambda expression or a method reference.

Consumer only takes one parameter. Lets see simple demo of consumer. 

Example 1 : Print String and Number using Consumer

public class ConsumerDemo {
    
    public static void main(String[] args) {
    
        // Print string values.
        Consumer<String> stringConsumer = str -> {
            System.out.println(str);
        };
        
        stringConsumer.accept("Welcome to Programming Blog");
        
        // Print Integer values.
        Consumer<Integer> integerConsumer = number -> {
            System.out.println(number);
        };
        
        integerConsumer.accept(123);
    }
}
Output :
Welcome to Programming Blog
123

Lest see another simple example of consumer.

Example 2 : Print Object properties using Consumer

import java.util.function.Consumer;

public class ConsumerDemo {
    
    public static void main(String[] args) {
        
        Customer customer = new Customer("abcd", 123456789);
        customerInfoConsumer.accept(customer);
    }
    
    // Consumer
    static Consumer<Customer> customerInfoConsumer = customer -> 
        System.out.println("Customer Name: " + customer.customerName + "\nCustomer Number:  " + customer.customerNumber);
    
        
    static class Customer {
        private final String customerName;
        private final int customerNumber;

        public Customer(String customerName, int customerNumber) {
            this.customerName = customerName;
            this.customerNumber = customerNumber;
        }
        
    }
}
Output :
Customer Name: abcd
Customer Number: 123456789

We have seen how to use accept() method now lets see how to use andThen() method in code.

Example 3 : Consumer andThen() method 

import java.util.function.Consumer; 
public class ConsumerDemo {

    public static void main(String[] args) {
        
         Consumer<String> first = a 
            -> System.out.println("Hello");
         
         Consumer<String> second = b 
            -> System.out.println(b);

         first.andThen(second).accept("Programmers");
        
    }
}
Output :
Hello
Programmers

 

BiConsumer in Java

As a name suggest, BiConsumer takes two arguments and does not return anything.

Same as Consumer BiConsumer contains only two methods :

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

 Lets see example of BiConsumer :

Example 3 : Sum of two number using BiConsumer

import java.util.function.BiConsumer;

public class ConsumerDemo {
    
    public static void main(String[] args) {
        
        BiConsumer<Integer, Integer> biConsumer = (value1, value2) 
		-> System.out.println("Sum of two number : " +(value1+value2));
				
	biConsumer.accept(10, 10);		        
        
    }
}
Output :
Sum of two number : 20

Example 5 : Print map values using BiConsumer

public class ConsumerDemo {
    
    static void Print(Map<Integer, String> map, String name){  
        
        System.out.println(name);

        map.forEach((key, val)->System.out.println(key+" "+val));  
    }  
    
    public static void main(String[] args) {
        
        Map<Integer, String> map = new HashMap<Integer,String>();  
        map.put(65, "A");  
        map.put(66, "B");  
        map.put(67, "C");  
        map.put(68, "D");
        map.put(69, "E");
        
        // Referring method  
        BiConsumer<Map<Integer, String>, String> biCon = ConsumerDemo::Print;  
        biCon.accept(map, "ASCII Characters");  
        
    }
}
Output :
ASCII Characters
65 A
66 B
67 C
68 D
69 E

Example 6 : BiConsumer andThen() method

import java.util.function.BiConsumer;

public class ConsumerDemo {

    public static void main(String[] args) {
        
        BiConsumer<Integer, Integer> first = (a,b) 
            -> System.out.println("Multiplication : " +10 * 10);
        
        BiConsumer<Integer, Integer> second = (c,d) 
            -> System.out.println("Addition is : "+(c + d));

        first.andThen(second).accept(5,5);
        
    }
}
Output :
Multiplication : 100
Addition is : 10
 

Happy Coding.

Other Java 8 related articles :

Predicate and BiPredicate in Java 8 with Examples