Змінення локальної змінної в forEachдає помилку компіляції:

Нормальний

    int ordinal = 0;
    for (Example s : list) {
        s.setOrdinal(ordinal);
        ordinal++;
    }

З Лямбдою

    int ordinal = 0;
    list.forEach(s -> {
        s.setOrdinal(ordinal);
        ordinal++;
    });

Будь-яка ідея, як це вирішити?

Використовуйте обгортку

Будь-який вид обгортки хороший.

З Java 8+ використовуйте або AtomicInteger:

AtomicInteger ordinal = new AtomicInteger(0);
list.forEach(s -> {
  s.setOrdinal(ordinal.getAndIncrement());
});

... або масив:

int[] ordinal = { 0 };
list.forEach(s -> {
  s.setOrdinal(ordinal[0]++);
});

З Java 10+ :

var wrapper = new Object(){ int ordinal = 0; };
list.forEach(s -> {
  s.setOrdinal(wrapper.ordinal++);
});

Примітка: будьте дуже обережні, якщо ви використовуєте паралельний потік. Ви можете не закінчити очікуваного результату. Інші рішення, такі як Стюарт, можуть бути більш адаптованими для цих випадків.

Для інших типів int

Звичайно, це все ще справедливо для інших типів int. Вам потрібно лише змінити тип обгортки на AtomicReferenceабо тип масиву цього типу. Наприклад, якщо ви використовуєте String, просто виконайте наступне:

AtomicReference<String> value = new AtomicReference<>();
list.forEach(s -> {
  value.set("blah");
});

Використовувати масив:

String[] value = { null };
list.forEach(s-> {
  value[0] = "blah";
});

Або з Java 10+:

var wrapper = new Object(){ String value; }
list.forEach(s->{
  wrapper.value = "blah";
});

Це досить близько до проблеми XY . Тобто, питання, яке задається, по суті, як мутувати захоплену локальну змінну від лямбда. Але актуальним завданням є те, як нумерувати елементи списку.

З мого досвіду, в 80% часу виникає питання, як мутувати захоплений локальний зсередини лямбда, є кращий спосіб продовжити. Зазвичай це передбачає зменшення, але в цьому випадку добре застосовується техніка запуску потоку над списками індексів:

IntStream.range(0, list.size())
         .forEach(i -> list.get(i).setOrdinal(i));

Якщо вам потрібно лише передати значення ззовні в лямбда, а не отримати його, ви можете зробити це за допомогою звичайного анонімного класу замість лямбда:

list.forEach(new Consumer<Example>() {
    int ordinal = 0;
    public void accept(Example s) {
        s.setOrdinal(ordinal);
        ordinal++;
    }
});

Оскільки використовувані змінні за межами ламди повинні бути (неявно) остаточними, ви повинні використовувати щось на кшталт AtomicIntegerабо записати власну структуру даних.

Див. Https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html#accessing-local-variables .

Якщо ви перебуваєте на Java 10, ви можете використовувати varдля цього:

var ordinal = new Object() { int value; };
list.forEach(s -> {
    s.setOrdinal(ordinal.value);
    ordinal.value++;
});

Альтернативою AtomicInteger(або будь-яким іншим об'єктом, здатним зберігати значення) є використання масиву:

final int ordinal[] = new int[] { 0 };
list.forEach ( s -> s.setOrdinal ( ordinal[ 0 ]++ ) );

Але дивіться відповідь Стюарта : може бути кращий спосіб впоратися зі своєю справою.

Я знаю, що це давнє запитання, але якщо вам подобається вирішити питання, враховуючи той факт, що зовнішня змінна повинна бути остаточною, ви можете просто зробити це:

final int[] ordinal = new int[1];
list.forEach(s -> {
    s.setOrdinal(ordinal[0]);
    ordinal[0]++;
});

Можливо, не найвишуканіший, а то й найправильніший, але це буде.

Ви можете обробити це, щоб вирішити компілятор, але пам’ятайте, що побічні ефекти в лямбдах відмовляються.

Цитувати javadoc

Побічні ефекти в параметрах поведінки для потокових операцій загалом відмовляються, оскільки вони часто можуть призвести до ненавмисних порушень вимоги без громадянства. Невелика кількість потокових операцій, таких як forEach () та peek (), може працювати лише через -ефекти; їх слід використовувати обережно

У мене була дещо інша проблема. Замість збільшення локальної змінної у forEach мені потрібно було призначити об'єкт локальній змінній.

Я вирішив це, визначивши приватний клас внутрішнього домену, який охоплює список, який я хочу повторити (countryList), і вихід, який я сподіваюся отримати з цього списку (foundCountry). Потім, використовуючи Java 8 "forEach", я повторюю поле списку, і коли об'єкт, який я хочу знайти, я присвоюю йому об'єкт полі виводу. Таким чином, це присвоює значення полі локальної змінної, не змінюючи локальної змінної. Я вважаю, що оскільки локальна змінна не змінюється, компілятор не скаржиться. Тоді я можу використовувати значення, яке я записав у полі виводу, поза списком.

Об'єкт домену:

public class Country {

    private int id;
    private String countryName;

    public Country(int id, String countryName){
        this.id = id;
        this.countryName = countryName;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getCountryName() {
        return countryName;
    }

    public void setCountryName(String countryName) {
        this.countryName = countryName;
    }
}

Об'єкт обгортки:

private class CountryFound{
    private final List<Country> countryList;
    private Country foundCountry;
    public CountryFound(List<Country> countryList, Country foundCountry){
        this.countryList = countryList;
        this.foundCountry = foundCountry;
    }
    public List<Country> getCountryList() {
        return countryList;
    }
    public void setCountryList(List<Country> countryList) {
        this.countryList = countryList;
    }
    public Country getFoundCountry() {
        return foundCountry;
    }
    public void setFoundCountry(Country foundCountry) {
        this.foundCountry = foundCountry;
    }
}

Повторна операція:

int id = 5;
CountryFound countryFound = new CountryFound(countryList, null);
countryFound.getCountryList().forEach(c -> {
    if(c.getId() == id){
        countryFound.setFoundCountry(c);
    }
});
System.out.println("Country found: " + countryFound.getFoundCountry().getCountryName());

Ви можете видалити метод класу обгортки "setCountryList ()" і зробити поле "countryList" остаточним, але я не отримав помилок компіляції, залишаючи ці дані такими, які є.

Щоб мати більш загальне рішення, ви можете написати загальний клас Wrapper:

public static class Wrapper<T> {
    public T obj;
    public Wrapper(T obj) { this.obj = obj; }
}
...
Wrapper<Integer> w = new Wrapper<>(0);
this.forEach(s -> {
    s.setOrdinal(w.obj);
    w.obj++;
});

(це варіант рішення, дане Альміром Кампосом).

У конкретному випадку це не гарне рішення, оскільки Integerце гірше, ніж intдля ваших цілей, так чи інакше це рішення є більш загальним, я думаю.

Так, ви можете змінювати локальні змінні зсередини лямбда (як показано в інших відповідях), але робити це не слід. Лямбди призначені для функціонального стилю програмування, і це означає: Відсутність побічних ефектів. Те, що ви хочете зробити, вважається поганим стилем. Це також небезпечно у разі паралельних потоків.

Вам слід або знайти рішення без побічних ефектів, або використовувати традиційне для циклу.