Unlocking Java Lambdas: How Functional Interfaces Power Modern Code

Lambda Basics

Java 8 introduced lambda expressions, allowing you to pass a block of code as an argument. A common example creates a new thread:

new Thread(() -> System.out.print("hello world")).start();

The lambda expression is compiled to an instance of the Runnable interface, which is a functional interface.

Runnable Interface and @FunctionalInterface

@FunctionalInterface
public interface Runnable {
    /**
     * When an object implementing interface <code>Runnable</code> is used to create a thread,
     * the <code>run</code> method is called in that separately executing thread.
     */
    void run();
}

The arrow -> is the lambda operator; the part before it represents the parameters, the part after it is the body. The Thread constructor expects a Runnable instance, so the lambda is automatically converted.

Understanding @FunctionalInterface

package java.lang;
import java.lang.annotation.*;
/**
 * An informative annotation type used to indicate that an interface type declaration is intended to be a functional interface as defined by the Java Language Specification.
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface FunctionalInterface {}

This annotation signals that the interface should have exactly one abstract method. The compiler enforces this rule, but even without the annotation, any interface that satisfies the functional‑interface requirements can be used with lambdas.

Practical Example: Sorting with Comparator

List<String> list = new ArrayList<>();
Collections.sort(list, (o1, o2) -> {
    if (o1.equals(o2)) {
        return 1;
    }
    return -1;
});

The second argument of Collections.sort is a Comparator<T> functional interface:

@FunctionalInterface
public interface Comparator<T> {
    int compare(T o1, T o2);
}

UnaryOperator and Function Interfaces

UnaryOperator<T>

is a specialization of Function<T,T> that takes a value and returns a value of the same type. It is used, for example, by List.replaceAll:

default void replaceAll(UnaryOperator<E> operator) {
    Objects.requireNonNull(operator);
    ListIterator<E> li = this.listIterator();
    while (li.hasNext()) {
        li.set(operator.apply(li.next()));
    }
}

Typical usage:

List<String> list = new ArrayList<>();
list.add("abc");
list.replaceAll(s -> s + "efg");
System.out.println(list); // [abcefg]

The UnaryOperator interface is defined as:

@FunctionalInterface
public interface UnaryOperator<T> extends Function<T, T> {
    static <T> UnaryOperator<T> identity() {
        return t -> t;
    }
}

The underlying Function interface provides the abstract apply method and default composition methods ( compose, andThen) as well as a static identity method.

Key Takeaways

Lambda expressions are syntactic sugar for creating instances of functional interfaces.

The @FunctionalInterface annotation documents intent and triggers compile‑time checks, but is not strictly required.

Default methods and methods from Object do not count toward the single abstract method requirement. UnaryOperator and other functional interfaces in java.util.function provide reusable building blocks for common operations.