Built-in Functional Interfaces

Java provides a set of ready-made functional interfaces in the package java.util.function. These are called built-in functional interfaces.

They are designed to make lambda expressions and Stream API more powerful, flexible, and reusable in Java programming.

What are Built-in Functional Interfaces?

Built-in functional interfaces are predefined interfaces introduced in Java 8 that contain only one abstract method and are mainly used with lambda expressions.

In simple words: Java already provides commonly used functional interfaces so you don’t need to create them again and again.

Why Are They Important?

• Reduce the need to create custom functional interfaces
• Work perfectly with lambda expressions
• Widely used in Stream API operations
• Help write clean, reusable, and modern Java code

Main Built-in Functional Interfaces

Java provides 4 main built-in functional interfaces in the java.util.function package that are widely used with Lambda expressions and Stream API.

1. Predicate<T>

Used for conditional checks (true/false results).

It is mainly used when you want to test a condition.

Method:

boolean test(T t);

👉 This method returns:

• true → if condition is satisfied
• false → if condition is not satisfied

Example:

import java.util.function.Predicate;

Predicate<Integer> isEven = n -> n % 2 == 0;

System.out.println(isEven.test(10));

Output:

true

Real Use Case:

• Filtering data in collections
• Validation checks (like age, email, password rules)

2. Function<T, R>

Function<T, R> is used when you want to take an input and return an output.

It is mainly used for data transformation in Java.

Method

R apply(T t);

👉 This method:

• Takes input of type T
• Returns output of type R

Example

import java.util.function.Function;

Function<Integer, Integer> square = x -> x * x;

System.out.println(square.apply(5));

Output

25

Real-World Use Cases

• Data transformation (e.g., converting one value to another)
• Mapping values in collections
• Formatting or processing input data

3. Consumer<T>

Consumer<T> is used when you want to take input and perform an action, but do not return any result.

It is mainly used for executing operations like printing, logging, etc.

Method

void accept(T t);

👉 This method:

• Takes input of type T
• Performs an action
• Returns nothing

Example

import java.util.function.Consumer;

Consumer<String> print = name -> System.out.println(name);

print.accept("Java");

Output

Java

Real-World Use Cases

• Printing data
• Logging information
• Performing actions on elements (e.g., in loops or streams)

4. Supplier<T>

Used to generate or provide a value without taking input.

Method:

T get();

Example:

import java.util.function.Supplier;

Supplier<Double> randomValue = () -> Math.random();

System.out.println(randomValue.get());

Output:

(Random value like 0.4567)

Real-World Use Cases

• Generating values
• Lazy initialization
• Factory methods

Other Important Functional Interfaces

Java also provides advanced variants:

5. BiPredicate<T, U>

BiPredicate<Integer, Integer> check = (a, b) -> a > b;

6. BiFunction<T, U, R>

BiFunction<Integer, Integer, Integer> add = (a, b) -> a + b;

7. BiConsumer<T, U>

BiConsumer<String, Integer> print = (name, age) ->
    System.out.println(name + " " + age);

Real-World Example (Combined Usage)

import java.util.function.*;

public class Test {
    public static void main(String[] args) {

        Predicate<Integer> isEven = n -> n % 2 == 0;
        Function<Integer, Integer> square = n -> n * n;
        Consumer<Integer> print = n -> System.out.println(n);
        Supplier<Integer> supplier = () -> 10;

        int value = supplier.get();

        if (isEven.test(value)) {
            print.accept(square.apply(value));
        }
    }
}

Built-in Functional Interfaces Summary

Advantages

• Predefined (no need to create interfaces)
• Clean and reusable code
• Works perfectly with lambda expressions
• Widely used in Stream API
• Improves functional programming style

When to Use Which?

• Use Predicate → filtering
• Use Function → mapping
• Use Consumer → actions
• Use Supplier → generating values

Conclusion

Built-in functional interfaces are the core building blocks of modern Java functional programming.

They help you write code that is:

• Shorter
• Cleaner
• More readable
• Highly reusable