All 15 Functional Interfaces & Method References questions
More in Functional Interfaces & Method References
How do the primitive-specialized functional interfaces (IntFunction, ToIntFunction, IntPredicate, IntUnaryOperator, etc.) avoid the performance cost of autoboxing, and when should you prefer them over the generic equivalents? How does the Predicate interface's default methods and(), or(), and negate() enable composing complex boolean conditions from simpler ones? What is the difference between a Consumer<T> and a BiConsumer<T,U>, and how would you use BiConsumer for operations needing two inputs but no return value, such as Map.forEach()? How would you convert a checked-exception-throwing method into a lambda usable with a standard functional interface (which doesn't declare any checked exceptions), given standard interfaces like Function don't permit checked exceptions in their abstract method signature? How would you implement a custom functional interface with generic type parameters, and what considerations apply when designing one instead of reusing a built-in java.util.function interface? How would you implement memoization (caching function results) as a higher-order function wrapping an existing Function, and what thread-safety considerations apply for a memoized function used concurrently? How would you use BiFunction combined with Stream's reduce() to implement a custom aggregation, and how does this relate to the more general concept of a fold operation in functional programming? How do lambda expressions get compiled at the bytecode level using invokedynamic, and how does this differ from how an anonymous inner class implementing the same functional interface would be compiled? How would you design a fluent, chainable validation API using functional interfaces, similar to how Comparator's thenComparing() works, but for validation rules that accumulate error messages rather than short-circuiting on the first failure? How does Java's type inference determine the target type for a lambda expression in an ambiguous overload scenario, and what happens when a lambda could match multiple overloaded methods accepting different functional interfaces?
Advertisement
Back to results for “Concurrency”
Java › Functional Interfaces & Method References

How does a lambda expression capture variables from its enclosing scope, and why must captured local variables be effectively final?

Advanced

Answer

A lambda capturing a local variable from its enclosing method doesn't actually capture the variable itself, but rather captures a copy of its value at the time the lambda is created (for local variables; instance/static fields are captured by reference to the containing object, allowing genuine mutation) -- Java enforces that any captured local variable must be effectively final (never reassigned after initialization, even if not explicitly marked final) specifically because the lambda might execute later, on a different thread, after the enclosing method has already returned and its local stack frame no longer exists, so allowing the lambda to observe or modify a since-changed local variable would create ill-defined, thread-unsafe semantics.
public Supplier<Integer> makeCounter() {
    int count = 0;
    // count++; // if uncommented, would cause a COMPILE ERROR: count is no longer effectively final
    return () -> count;  // captures the VALUE of count (0) at lambda creation time
}

// Workaround for genuine mutable state: use an array or an AtomicInteger as a container
AtomicInteger counter = new AtomicInteger(0);
Runnable increment = counter::incrementAndGet;  // captures the reference, container itself is mutable
Real-world example A background task submitted with a lambda capturing a local loop variable in a for-loop is a classic pitfall (fixed in Java 8+ since each iteration effectively creates a fresh variable binding for enhanced for-loops, unlike some older languages), but attempting to have multiple lambdas share and mutate a captured counter directly requires wrapping it in a mutable container like AtomicInteger, since the raw local variable itself cannot be reassigned once captured.

Common follow-ups: Why does capturing an instance field (via 'this') not have the same effectively-final restriction that local variables do?;What's the specific mechanism (variable capture into a synthetic final copy) the compiler uses under the hood to implement this?

Concurrency & Threads;Java Fundamentals: Syntax Data Types & Operators
All 15 Functional Interfaces & Method References questions