Lambdas and functional interfaces

A lambda is a short, nameless function you can pass around: x -> x * 2. It works wherever Java expects an interface with exactly one abstract method.

A mental model

Instead of writing a whole recipe card and naming it, you hand over a sticky note with the one step ("double it") for the other person to apply wherever they need.

How it works

The arrow separates the parameters from the body: (a, b) -> a + b. A body with one expression returns it; a block in braces needs return.

The target is a functional interface such as Function<T,R> (one input, one output), Predicate<T> (returns boolean), Consumer<T> (returns nothing) or Supplier<T> (no input, returns a value). The compiler infers the types from the context.

A lambda can read local variables from the surrounding method, but only if they are effectively final (never reassigned). This is why you cannot increment a local counter from inside a lambda.

Going deeper

A lambda is not a new kind of object with its own this: this inside it means the enclosing class. For a named behaviour with its own state, use a class instead.

Lambdas hide control flow: an exception thrown inside is thrown at the place the lambda is called (for example in the middle of a stream pipeline). Checked exceptions cannot be thrown from the standard functional interfaces, so wrap them.

Avoid side effects inside lambdas that run in parallel streams or on other threads; captured mutable state becomes a data race.

Under the hood

The compiler turns a lambda into a private synthetic method and uses invokedynamic with LambdaMetafactory to create the interface instance at first use. Non-capturing lambdas are cached as a single instance.

Common mistakes

• Mutating a captured local variable (compile error) and "fixing" it with a one-element array.
• Doing blocking or stateful work in a stream lambda.
• Putting long logic in a lambda instead of a named method.