Effectively Final Variables in Lambdas

Direct Answer

'Effectively final' means a local variable or parameter is never reassigned after its initial assignment. A lambda may capture it without an explicit final keyword, but the lambda captures the value of that local variable rather than sharing a mutable local-variable slot.

Code Example

import java.util.function.Function;

public class EffectivelyFinalDemo {
    void demo() {
        String greeting = "Hello";
        Runnable print = () -> System.out.println(greeting);

        final int multiplier = 3;
        Function<Integer, Integer> triple = x -> x * multiplier;

        int count = 0;
        count++;
        // Runnable broken = () -> System.out.println(count); // does not compile

        int[] mutableCount = {0};
        Runnable increment = () -> mutableCount[0]++; // legal, but mutable
        increment.run();
    }
}

The array example compiles because the captured reference is not reassigned; its array contents can still change. That is not a thread-safety technique. Concurrent updates would need an appropriate atomic or synchronised design.

Common Mistakes & Pitfalls

• Thinking you must write final: Believing the variable needs the final keyword. Effectively final means the compiler infers it — no keyword is needed as long as you never reassign.
• Reassigning a captured variable: Updating a counter or accumulator like total += x in the surrounding method, then wondering why the lambda no longer compiles.
• Reaching for the array hack: Using a single-element array int[] c = {0} to fake a mutable counter inside a lambda. It compiles, but it's a code smell and is unsafe across threads.