Lambda Expressions and Functional Interfaces in Java

A functional interface is any interface with exactly one abstract method — Runnable, Comparator, Callable, Function, Predicate, and so on. The @FunctionalInterface annotation documents intent and enforces the single-abstract-method property.

A lambda expression is a compact syntax for implementing a functional interface inline. (a, b) -> a.length() - b.length() is a lambda; the compiler uses target typing to figure out from context which functional interface it implements. In the same line of code, that same expression could satisfy a Comparator or a BiFunction — target type decides.

The standard functional interfaces live in java.util.function. The big four are Function, Predicate, Consumer, and Supplier. Plus Bi- variants for two inputs, UnaryOperator and BinaryOperator for same-type transformations, and primitive specializations like IntFunction or ToIntFunction that avoid boxing — important in hot paths over millions of elements.

Under the hood: lambdas are not compiled to anonymous classes, contrary to a common misconception. The compiler emits an `invokedynamic` instruction that calls LambdaMetafactory at runtime. The metafactory decides on a strategy — typically generates a lightweight class via java.lang.invoke and caches it. The payoff: stateless lambdas are singletons — () -> 42 allocates exactly once ever — and the JIT can inline the lambda body into the call site, eliminating dispatch overhead. Benchmarks show lambdas about 25% faster than equivalent anonymous classes.

One important constraint: captured local variables must be effectively final — assigned once, never reassigned. The restriction exists because lambdas may outlive the enclosing method (stored in fields, submitted to executors), and mutable captured state would require expensive synchronization. For genuine mutation, use AtomicInteger or accumulate via reduce/collect rather than mutating in forEach.