Можно ли обратиться из Lambda к локальной переменной метода, в котором определена Lambda?

Ответ на вопрос о Lambda и локальных переменных

Да, но только к effectively final переменным

Вы можете обратиться из Lambda-выражения к локальной переменной метода, но эта переменная должна быть effectively final — то есть её значение не должно меняться после инициализации.

Что такое effectively final?

Effectively final — это переменная, которая инициализируется один раз и больше не изменяется. Начиная с Java 8, не нужно явно писать модификатор final, компилятор сам определит такие переменные.

public void demonstrateLambda() {
    int x = 10; // effectively final
    String message = "Hello"; // effectively final
    
    Runnable r = () -> System.out.println(x + " " + message);
    r.run(); // Output: 10 Hello
}

Почему это ограничение?

Ламбда-выражение захватывает значения локальных переменных, но не сами переменные. Если переменная будет изменена, во время выполнения ламбды это значение станет непредсказуемым. Это ограничение гарантирует потокобезопасность и предсказуемость кода.

Правильно: переменная не меняется

public void correctExample() {
    int count = 5; // effectively final
    
    IntStream.range(0, 10)
        .forEach(i -> System.out.println(count)); // ✅ Работает
}

Неправильно: переменная меняется

public void incorrectExample() {
    int count = 5;
    count++; // Теперь переменная больше не effectively final!
    
    IntStream.range(0, 10)
        .forEach(i -> System.out.println(count)); // ❌ Ошибка компиляции!
}

Параметры ламбды

Параметры самой ламбды в этом плане полностью независимы:

List<Integer> numbers = Arrays.asList(1, 2, 3);

numbers.forEach(x -> {
    x = x * 2; // ✅ Можно менять параметр x
    System.out.println(x);
});

Захват значений для объектов

Для объектов правило сложнее. Вы можете менять содержимое объекта, но не можете переприсвоить саму переменную:

public void objectExample() {
    List<String> items = new ArrayList<>(); // effectively final
    items.add("A"); // ✅ Можно менять содержимое
    
    Runnable r = () -> System.out.println(items); // ✅ Работает
    
    // items = new ArrayList<>(); // ❌ Нельзя переприсвоить!
}

Решение: использование массивов

Если нужно менять примитивное значение, используйте массив или обёртку:

public void arrayWorkaround() {
    int[] counter = {0}; // effectively final массив
    
    IntStream.range(0, 5)
        .forEach(i -> counter[0]++); // ✅ Работает!
    
    System.out.println(counter[0]); // Output: 5
}

// Или через AtomicInteger
public void atomicExample() {
    AtomicInteger counter = new AtomicInteger(0);
    
    IntStream.range(0, 5)
        .forEach(i -> counter.incrementAndGet());
    
    System.out.println(counter.get()); // Output: 5
}

Переменные из охватывающих областей

Ламбда может захватывать переменные не только из прямого метода, но и из более внешних блоков, если они effectively final:

public class Example {
    private int classVariable = 10; // ✅ Доступна (поле класса)
    
    public void outer() {
        int outerVar = 20; // effectively final
        
        Runnable r = () -> {
            System.out.println(classVariable); // ✅ Работает
            System.out.println(outerVar);     // ✅ Работает
        };
    }
}

Заключение

Ламбда-выражения могут захватывать локальные переменные методов, но эти переменные должны быть effectively final. Это ограничение обеспечивает потокобезопасность и предсказуемость кода. Если нужна изменяемость, используйте массивы, объекты-обёртки (AtomicInteger) или переменные на уровне класса.