修改中的局部变量forEach会产生编译错误：

正常

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

与Lambda

    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++);
});

注意：如果使用并行流，非常小心。您可能无法获得预期的结果。诸如Stuart的其他解决方案可能会更适合这些情况。

对于其他类型 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问题。也就是说，所要问的问题本质上是如何从lambda突变捕获的局部变量。但是，眼下的实际任务是如何为列表中的元素编号。

以我的经验，在高达80％的时间里，有一个问题是如何从lambda内突变捕获的局部基因，这是一种更好的方法。通常，这涉及减少，但是在这种情况下，在列表索引上运行流的技术非常适用：

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

如果您只需要从外部将值传递给lambda而不是将其取出，则可以使用常规的匿名类而不是lambda来实现：

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 ]++ ) );

但是请参阅Stuart的回答：可能有更好的方式处理您的案件。

我知道这是一个老问题，但是如果您对解决方法感到满意，考虑到外部变量应该是最终变量，则可以执行以下操作：

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

也许不是最优雅的，甚至不是最正确的，但它会做到的。

您可以将其包装起来以解决编译器问题，但是请记住，不要鼓励使用lambda的副作用。

引用javadoc

通常不鼓励行为参数对流操作的副作用，因为它们经常会导致无意识地违反无状态要求。少量流操作（例如forEach（）和peek（））只能通过side操作-效果；这些应该小心使用

我有一个稍微不同的问题。我不需要在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”定为final，但是我没有遇到编译错误，使这些详细信息保持原样。

要获得更通用的解决方案，可以编写一个通用的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++;
});

（这是Almir Campos提供的解决方案的变体）。

在特定情况下，这不是一个好的解决方案，因为Integer比int您的目的还差，无论如何，我认为这种解决方案更为笼统。

是的，您可以从lambda内部修改局部变量（以其他答案所示的方式），但您不应该这样做。Lambda一直是功能性编程风格，这意味着：无副作用。您想做的事被认为是不好的风格。在并行流的情况下也很危险。

您应该找到没有副作用的解决方案，或者使用传统的for循环。