Functional Interfaces

🔍 What Is It?

Core Functional Interfaces:

Function<T, R> — takes T, returns R

• →apply(T t): R
• →andThen(Function): compose after
• →compose(Function): compose before

Predicate<T> — takes T, returns boolean

• →test(T t): boolean
• →and(Predicate), or(Predicate), negate()

Consumer<T> — takes T, returns void

• →accept(T t)
• →andThen(Consumer)

Supplier<T> — takes nothing, returns T

• →get(): T

BiFunction<T, U, R> — takes T and U, returns R

BiPredicate<T, U> — takes T and U, returns boolean

BiConsumer<T, U> — takes T and U, returns void

Primitive Specializations (avoid boxing overhead):

• →IntFunction<R>, LongFunction<R>, DoubleFunction<R>
• →IntPredicate, LongPredicate, DoublePredicate
• →IntConsumer, IntSupplier, IntUnaryOperator
• →ToIntFunction<T>, ToLongFunction<T>

UnaryOperator<T> — Function<T, T> (same type in and out)

BinaryOperator<T> — BiFunction<T, T, T>

🎯 Why Do We Need It?

Functional interfaces are the types that lambdas implement. Without them, there would be no standard way to pass functions as arguments. The java.util.function package provides standard types that the entire Java ecosystem uses — Streams, Optional, CompletableFuture, and all major frameworks speak this language.

🏗️ What Happens in Real Projects?

Functional interfaces appear everywhere:

// Spring Data Specification (Predicate)
Specification<User> isActive = (root, query, cb) -> cb.isTrue(root.get("active"));

// Optional (Supplier, Consumer, Function)
Optional.ofNullable(value)
    .map(String::toUpperCase)          // Function
    .filter(s -> s.length() > 3)       // Predicate
    .ifPresent(System.out::println);   // Consumer

// CompletableFuture (Function, Consumer, Supplier)
CompletableFuture.supplyAsync(() -> fetchData())  // Supplier
    .thenApply(data -> transform(data))            // Function
    .thenAccept(result -> save(result));            // Consumer

⚙️ How It Works

@FunctionalInterface annotation:

Optional but recommended. Causes a compile error if the interface has more than one abstract method. Documents intent.

Function Composition:

Functions can be composed into pipelines:

Function<String, String> trim = String::trim;
Function<String, String> upper = String::toUpperCase;
Function<String, Integer> length = String::length;

Function<String, Integer> pipeline = trim.andThen(upper).andThen(length);
int result = pipeline.apply("  hello  ");  // 5

Predicate Composition:

Predicate<String> notEmpty = s -> !s.isEmpty();
Predicate<String> notTooLong = s -> s.length() <= 100;
Predicate<String> valid = notEmpty.and(notTooLong);

💻 Example

Functional Interfaces in Enterprise Code — How to use and compose functional interfaces for clean, reusable business logic.

// Function<T, R> — transformation
Function<String, Integer> strLength = String::length;
Function<Integer, String> intToStr = n -> "Value: " + n;

// Compose: first strLength, then intToStr
Function<String, String> composed = strLength.andThen(intToStr);
System.out.println(composed.apply("hello"));  // "Value: 5"

// Predicate<T> — boolean test
Predicate<String> isEmail = s -> s.contains("@") && s.contains(".");
Predicate<String> notBlank = s -> !s.isBlank();
Predicate<String> validEmail = notBlank.and(isEmail);
Predicate<String> invalidEmail = validEmail.negate();

System.out.println(validEmail.test("user@example.com"));  // true
System.out.println(validEmail.test("notanemail"));         // false

// Consumer<T> — side effect
Consumer<String> log = msg -> System.out.println("[LOG] " + msg);
Consumer<String> audit = msg -> auditService.record(msg);
Consumer<String> logAndAudit = log.andThen(audit);
logAndAudit.accept("User login");

// Supplier<T> — lazy value production
Supplier<Connection> dbConn = () -> dataSource.getConnection();
// Connection not created until dbConn.get() is called

// UnaryOperator<T> — transform same type
UnaryOperator<String> normalize = s -> s.trim().toLowerCase();
UnaryOperator<BigDecimal> roundCurrency = 
    n -> n.setScale(2, RoundingMode.HALF_UP);

// BinaryOperator<T> — combine two of same type
BinaryOperator<BigDecimal> sum = BigDecimal::add;
BinaryOperator<String> concat = String::concat;

🤔 Common Confusions

🚨 Common Production Issues

✅ Best Practices

🏛️ Architect's Note

💬 Frequently Asked Questions

🎯 Key Takeaways

🔗 Related Topics

🎯 Practice this topic in interviews

↗ Where this topic fits