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

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

Interface	Input	Output	Purpose
Predicate<T>	Yes	Boolean	Condition check
Function<T, R>	Yes	Yes	Transformation
Consumer<T>	Yes	No	Action
Supplier<T>	No	Yes	Value generation

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