Изменение локальной переменной в 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на массив этого типа. Например, если вы используете a 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++;
    }
});

Поскольку используемые переменные извне lamda должны быть (неявно) окончательными, вы должны использовать что-то вроде 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для вашей цели, в любом случае, я думаю, это решение является более общим.

Да, вы можете изменять локальные переменные изнутри лямбда-выражений (как показано в других ответах), но вы не должны этого делать. Лямбды предназначены для функционального стиля программирования, а это означает: отсутствие побочных эффектов. То, что вы хотите делать, считается плохим стилем. Это также опасно в случае параллельных потоков.

Вы должны либо найти решение без побочных эффектов, либо использовать традиционный цикл for.