Что значит переменная effectivelly final?

Effectively Final переменные

Effectively final — это переменная, которая не объявлена с ключевым словом final, но после инициализации никогда не изменяется. Это концепция, введённая в Java 8 для поддержки использования переменных в лямбда-выражениях и анонимных классах.

Что это значит

Переменная считается effectively final, если:

1. Объявлена без ключевого слова final
2. Инициализирована один раз
3. Никогда не изменяется после инициализации

Компилятор Java автоматически определяет, является ли переменная effectively final.

Примеры

Correctly Effectively Final

public void demonstrateEffectivelyFinal() {
    int x = 10; // effectively final
    String name = "Alice"; // effectively final
    
    Runnable runnable = () -> {
        System.out.println(x); // OK - не изменяется
        System.out.println(name); // OK - не изменяется
    };
}

НЕ Effectively Final

public void demonstrateNonEffectivelyFinal() {
    int x = 10;
    x = 20; // Изменяем значение
    
    Runnable runnable = () -> {
        // System.out.println(x); // ОШИБКА - не effectively final!
    };
}

Почему это нужно?

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

public void searchWithLambda() {
    String searchTerm = "Java"; // effectively final
    
    // Использование в Stream API
    List<String> books = Arrays.asList("Java Guide", "Python Basics", "Java Advanced");
    List<String> result = books.stream()
        .filter(book -> book.contains(searchTerm)) // OK
        .collect(Collectors.toList());
    
    System.out.println(result); // [Java Guide, Java Advanced]
}

Сравнение: final vs effectively final

public void compareApproaches() {
    // Явно final
    final int explicitFinal = 10;
    
    // Effectively final
    int implicitFinal = 20;
    
    // В обоих случаях можно использовать в лямбде
    Runnable r = () -> {
        System.out.println(explicitFinal); // OK
        System.out.println(implicitFinal); // OK
    };
    
    // Но только для мутирования implicitFinal
    // implicitFinal = 30; // ОШИБКА - нарушает effectively final
}

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

Лямбда-выражения в Java — это синтаксический сахар над анонимными классами:

// Лямбда
int x = 10;
Runnable r = () -> System.out.println(x);

// Эквивалентно анонимному классу
Runnable r2 = new Runnable() {
    @Override
    public void run() {
        // x должна быть final, иначе объект класса не сможет безопасно хранить её значение
        System.out.println(x);
    }
};

Причина: Лямбда создаёт локальную копию значения переменной. Если бы переменная могла изменяться, возникали бы проблемы с синхронизацией между потоками и непредсказуемым поведением.

Практический пример: обработка коллекций

public class DataProcessor {
    public void processData() {
        int batchSize = 100; // effectively final
        String environment = "production"; // effectively final
        
        List<User> users = Arrays.asList(
            new User(1, "Alice"),
            new User(2, "Bob"),
            new User(3, "Charlie")
        );
        
        // Использование в Stream API
        Map<Integer, List<User>> grouped = users.stream()
            .filter(user -> user.getId() < batchSize) // OK
            .collect(Collectors.groupingBy(
                user -> user.getId() / (batchSize / 10) // OK
            ));
        
        System.out.println("Environment: " + environment); // OK
    }
}

Частая ошибка

public void commonMistake() {
    int counter = 0;
    
    // Попытка использовать counter в лямбде
    Runnable increment = () -> {
        // counter++; // ОШИБКА - нарушает effectively final
    };
    
    // Решение: использовать AtomicInteger
    AtomicInteger atomicCounter = new AtomicInteger(0);
    Runnable incrementSafe = () -> {
        atomicCounter.incrementAndGet(); // OK
    };
}

Резюме

Effectively final — это автоматическое определение компилятором переменной, которая:

• Объявлена без final
• Инициализирована один раз
• Никогда не меняется

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