Java 8 introduces a new package containing Functional Interfaces called java.util.function. In this package, we have many interfaces like Consumer, Supplier, Predicate, … In this tutorial, we will learn about Consumer Functional Interface.
The content of this interface is as follows:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 |
package java.util.function; import java.util.Objects; /** * Represents an operation that accepts a single input argument and returns no * result. Unlike most other functional interfaces, {@code Consumer} is expected * to operate via side-effects. * * <p>This is a <a href="package-summary.html">functional interface</a> * whose functional method is {@link #accept(Object)}. * * @param <T> the type of the input to the operation * * @since 1.8 */ @FunctionalInterface public interface Consumer<T> { /** * Performs this operation on the given argument. * * @param t the input argument */ void accept(T t); /** * Returns a composed {@code Consumer} that performs, in sequence, this * operation followed by the {@code after} operation. If performing either * operation throws an exception, it is relayed to the caller of the * composed operation. If performing this operation throws an exception, * the {@code after} operation will not be performed. * * @param after the operation to perform after this operation * @return a composed {@code Consumer} that performs in sequence this * operation followed by the {@code after} operation * @throws NullPointerException if {@code after} is null */ default Consumer<T> andThen(Consumer<? super T> after) { Objects.requireNonNull(after); return (T t) -> { accept(t); after.accept(t); }; } } |
Because the Consumer is a Functional Interface, it only defines an abstract method accept(). Besides that, as you can see, it also defines an andThen() default method.
The accept() method is defined with a generic parameter and does not return anything. And we will use this parameter to manipulate, calculate.
For example, we often use the Consumer interface in the forEach() method of Collection objects like List, Set, …
|
1 2 3 4 5 6 7 8 9 10 11 12 |
package com.huongdanjava.javaexample; import java.util.Arrays; import java.util.List; public class Example { public static void main(String[] args) { List<String> s = Arrays.asList("Khanh", "Quan"); s.stream().forEach(System.out::println); } } |
The forEach() method will pass the value of each element in list s to the parameter of the accept() method of the Consumer interface, and here I am using System.out.println() to print the value of this element to the console.
Result:
The andThen() method implies that we have a lot of work to do, and using this method allows us to do many things at the same time.
Eg:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
package com.huongdanjava.javaexample; import java.util.function.Consumer; public class Example { public static void main(String[] args) { Consumer<String> c1 = s -> System.out.println(s + " Khanh"); Consumer<String> c2 = s -> System.out.println(s + " Huong Dan Java"); c1.andThen(c2).accept("Hello"); } } |
In the example above, we will perform from action 1 to action 2 with the value passed as “Hello”.
Result:
In the java.util.function package, we also have some variants of the Consumer Functional Interface:
- IntConsumer: with parameters in the accept() method of type Integer.
- DoubleConsumer: with parameters in the accept() method of type Double.
- LongComsumer: with parameters in the accept() method of type Long.
BiConsumer: The accept() method of this interface contains two parameters with different value types, but the function is similar to the Consumer interface.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
package com.huongdanjava.javaexample; import java.util.function.BiConsumer; public class Example { public static void main(String[] args) { BiConsumer<String, String> bc = (a, b) -> System.out.println("Hello: " + a + ", hello: " + b); bc.accept("Khanh", "Huong Dan Java"); } } |
Result:
