Functional Interfaces

#Introduction

One of the most important Java 8 topics. If Streams are the car, Functional Interfaces are the engine.

Most developers memorize filter(), map() and forEach(), but very few understand why these methods accept lambdas. This chapter changes that. You'll master what a functional interface is, @FunctionalInterface, lambda expressions, Predicate, Function, Consumer, Supplier, UnaryOperator, BinaryOperator, primitive functional interfaces, function composition and predicate chaining.

#What is a Functional Interface?

A Functional Interface is an interface that has exactly one abstract method.

@FunctionalInterface
interface Calculator {

    int calculate(int a, int b);
}

✅ Valid — only one abstract method.

This is not a functional interface:

interface Calculator {

    int add(int a, int b);

    int subtract(int a, int b);
}

❌ Because there are two abstract methods. (With @FunctionalInterface on it, the compiler reports an error.)

Why Did Java Introduce Functional Interfaces?

Before Java 8:

Runnable r = new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello");
    }
};

Java 8:

Runnable r = () -> System.out.println("Hello");

Cleaner. Shorter. Readable.

#What is a Lambda?

A lambda is simply an implementation of a functional interface.

Calculator add = (a, b) -> a + b;

This is equivalent to:

Calculator add = new Calculator() {
    @Override
    public int calculate(int a, int b) {
        return a + b;
    }
};

The compiler creates the implementation for you.

#The Six You Must Know

Instead of creating your own, Java provides common ones in java.util.function:

If you master these six, Streams become much easier.

#Predicate

Meaning: ask a YES/NO question.

boolean test(T t);

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

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

true

Stream Connection

numbers.stream()
       .filter(n -> n % 2 == 0)

What does filter() expect? A Predicate<Integer>. Internally:

filter(Predicate<? super T> predicate)

One of the most common interview questions.

Predicate Chaining

Need adult (age ≥ 18) AND salary > 50,000:

Predicate<Employee> adult = e -> e.getAge() >= 18;

Predicate<Employee> rich = e -> e.getSalary() > 50000;

Predicate<Employee> result = adult.and(rich);

Other operations:

adult.or(rich);
adult.negate();

#Function<T, R>

Meaning: transform one object into another.

R apply(T t);

Function<String, Integer> length = String::length;

System.out.println(length.apply("Java"));

4

Stream Connection

employees.stream()
         .map(Employee::getName)

What does map() accept? A Function<Employee, String>. Internally:

map(Function<? super T, ? extends R> mapper)

Function Composition

Need name → uppercase → length.

Function<String, String> upper = String::toUpperCase;      // step 1
Function<String, Integer> length = String::length;         // step 2

Function<String, Integer> result = upper.andThen(length);  // combine

System.out.println(result.apply("java"));

compose()

Reverse order. f.compose(g) means run g first, then f:

#Consumer

Meaning: consume a value, return nothing.

void accept(T t);

Consumer<String> print = System.out::println;

print.accept("Hello");

Hello

Stream Connection

stream.forEach(System.out::println);

What does forEach() accept? A Consumer<T>.

#Supplier

Meaning: provide a value. No input, one output.

T get();

Supplier<UUID> supplier = UUID::randomUUID;

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

Every call creates a new UUID.

Stream Connection

Stream.generate(UUID::randomUUID)

generate() accepts a Supplier.

#UnaryOperator

A special type of Function: input and output are the same type.

UnaryOperator<String> upper = String::toUpperCase;

System.out.println(upper.apply("java"));

JAVA

Equivalent to Function<String, String>, but more readable.

#BinaryOperator

Two inputs, one output — all the same type.

BinaryOperator<Integer> add = Integer::sum;

System.out.println(add.apply(10, 20));

30

Stream Connection

reduce(Integer::sum)

reduce() accepts a BinaryOperator.

#Primitive Functional Interfaces

Avoid boxing.

IntPredicate even = n -> n % 2 == 0;

IntUnaryOperator square = n -> n * n;

These are faster because they avoid boxing.

#Real Spring Boot Examples

// Filter active users
Predicate<User> active = User::isActive;

users.stream()
     .filter(active)
     .toList();

// Convert entity to DTO
Function<User, UserDTO> mapper = UserMapper::toDto;

users.stream()
     .map(mapper)
     .toList();

// Logging
Consumer<Order> logger = System.out::println;
orders.forEach(logger);

// Generate token
Supplier<String> token = () -> UUID.randomUUID().toString();

#How Streams Use Functional Interfaces

Memorize this table. It's a very common interview question.

#Practice Problems

Predicate

1. Check if a number is even.
2. Check if a string is empty.
3. Check if an employee's salary is greater than 50,000.
4. Combine two predicates using and().
5. Use negate() to find odd numbers.

Function

1. Convert a string to uppercase.
2. Find the length of a string.
3. Convert Employee to employee name.
4. Convert Employee to salary.
5. Chain two functions using andThen().

Consumer

1. Print employee names.
2. Print salaries.
3. Print uppercase names.
4. Log employee details.
5. Use forEach() with a consumer.

Supplier

1. Generate a UUID.
2. Generate a random integer.
3. Generate the current timestamp.
4. Return "Guest" as a default user.
5. Create a new Employee object.

5+ Years Interview Challenge

Implement an employee processing pipeline using reusable functional interfaces.

Predicate<Employee> highSalary = e -> e.getSalary() > 60_000;

Function<Employee, String> toName = Employee::getName;

Consumer<String> print = System.out::println;

employees.stream()
         .filter(highSalary)
         .map(toName)
         .sorted()
         .forEach(print);

Why is this good?

• Business rules (Predicate) are reusable.
• Mapping logic (Function) is reusable.
• Output logic (Consumer) is reusable.
• The stream pipeline reads like a sentence.

A pattern you'll often see in well-designed enterprise applications.

#Senior Java Tips

1. Think in terms of intent

Instead of remembering interface names, remember their purpose:

2. Prefer method references when they improve readability

Instead of name -> name.toUpperCase(), use String::toUpperCase. But don't force method references if they make the code harder to understand.

3. Don't create custom functional interfaces unnecessarily

Before writing your own interface, check whether one from java.util.function already fits your use case. Standard interfaces make your code easier for other Java developers to understand.