A Detailed Guide On Java Built-In Functional Interfaces
This lesson details about the various functional interfaces that fall under major 4 categories.
Table of Contents
Introduction
Java provides a lot of predefined functional interfaces for us to use.
The new Function API introduced in Java SE 8 defines several built-in functional interfaces, providing target types for lambda expressions and method references.
So if we break down all the interfaces we were given in the functions package, they are packed into 4 types, and all of them are either of the four interfaces we are discussing.
- Consumer
- Supplier
- Function
- Predicate
Sketch

Types of Functional Interfaces
As per the sketch above, let us talk in detail about these functional interfaces.
1. Consumer interface
The Consumer
interface in Java is a functional interface that takes a single argument of a specified type and returns no result. Its functional method is called accept()
. Here is the syntax for the Consumer interface:
@FunctionalInterface
public interface Consumer<T> {
void accept(T t);
}
In this example, T
a type parameter represents the type of argument that the Consumer
will accept. The @FunctionalInterface
annotation is optional but often indicates that the interface is intended to be a functional interface.
To use the Consumer
interface, you can create an instance of it and pass it as an argument to a method that expects a Consumer
.
An example is shown below:
List<String> names = Arrays.asList("John", "Jane", "Bob");
Consumer<String> printName = name -> System.out.println(name);
names.forEach(printName);
In this example, a Consumer
instance called printName
is created using a lambda expression that takes a String
argument and prints it to the console. The forEach()
method of the List
class is called with printName
as an argument, causing it to be executed for each element in the list. As a result, the names "John", "Jane", and "Bob" are printed to the console.
The Consumer
interface is commonly used in scenarios where you must act on each collection element, such as printing, logging, or processing the elements.
2. Supplier Interface
The Supplier
interface in Java is a functional interface that takes no arguments and returns a specified type value. Its functional method is called get()
. This is opposite to Consumer
Interface.
Here is the syntax for the Supplier
interface:
@FunctionalInterface
public interface Supplier<T> {
T get();
}
In this example, T
is a type parameter that represents the type of value that the Supplier
will return. The @FunctionalInterface
annotation is optional but is often used to indicate that the interface is intended to be a functional interface.
To use the Supplier
interface, you can create an instance of it and call its get()
method to obtain a value. Here is an example:
Supplier<Integer> randomNumberSupplier = () -> (int) (Math.random() * 100);
int randomNumber = randomNumberSupplier.get();
System.out.println("Random number: " + randomNumber);
In this example, a Supplier
instance called randomNumberSupplier
is created using a lambda expression that generates a random integer between 0
and 100
. The get()
method of Supplier
is then called to obtain a random number printed to the console.
The Supplier
interface is commonly used when generating or supplying values on demand, such as when initializing objects or populating collections.
3. Function Interface
The Function
interface in Java is a functional interface that takes a single argument of a specified type and returns a value of a different type. Its functional method is called apply()
.
Here is an example of using the Function
interface:
Function<String, Integer> stringLength = str -> str.length();
int length = stringLength.apply("hello");
System.out.println("Length of string: " + length);
In this example, a Function
instance called stringLength
is created using a lambda expression that takes a String
argument and returns its length as an Integer
. The apply()
method of the Function is then called with the string "hello" as an argument, which returns the length of the string (which is 5). The length is then printed to the console.
The Function
interface is commonly used in scenarios where you need to transform or convert values, such as when processing data or performing calculations. Another example of using the Function
interface is to convert a string to an integer, like this:
Function<String, Integer> stringToInt = str -> Integer.parseInt(str);
int num = stringToInt.apply("42");
System.out.println("Number: " + num);
In this example, a Function
instance called stringToInt
is created using a lambda expression that takes a String
argument and converts it to an Integer
. The apply()
method of the Function
is then called with the string "42" as an argument, which returns the integer value 42. The integer is then printed to the console.
4. Predicate Interface
The Predicate
interface in Java is a functional interface that takes a single argument of a specified type and returns a boolean value. Its functional method is called test()
. Here is an example of using the Predicate
interface:
Predicate
takes an object/variable and checks to see if that satisfies some criteria. Most of the time we use this in filtering data.
Predicate<Integer> isEven = num -> num % 2 == 0;
boolean result1 = isEven.test(4); // returns true
boolean result2 = isEven.test(7); // returns false
System.out.println("Result1: " + result1);
System.out.println("Result2: " + result2);
In this example, a Predicate
instance called isEven
is created using a lambda expression that takes an Integer
argument and checks whether it is even (by checking whether the remainder after division by 2 is 0). The test()
method of the Predicate
is then called with the integers 4 and 7 as arguments, which return true
and false
respectively. The results are then printed to the console.
The Predicate
interface is commonly used in scenarios where you must test or filter values based on some condition, such as when searching or sorting data. Another example of using the Predicate
interface is to check if a string is longer than a certain length, like this:
Predicate<String> isLongerThan5 = str -> str.length() > 5;
boolean result3 = isLongerThan5.test("hello"); // returns false
boolean result4 = isLongerThan5.test("goodbye"); // returns true
System.out.println("Result3: " + result3);
System.out.println("Result4: " + result4);
In this example, a Predicate
instance called isLongerThan5
is created using a lambda expression that takes a String
argument and checks whether its length is greater than 5. The test()
method of the Predicate
is then called with the strings "hello" and "goodbye" as arguments, which return false
and true
respectively. The results are then printed to the console.
Next Up?
You will learn each in detail in the next lessons with examples and explanations.
Gopi Gorantala Newsletter
Join the newsletter to receive the latest updates in your inbox.