Modificar una variable local en forEachda un error de compilación:

Normal

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

Con Lambda

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

¿Alguna idea de cómo resolver esto?

Usa una envoltura

Cualquier tipo de envoltorio es bueno.

Con Java 8+ , use un AtomicInteger:

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

... o una matriz:

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

Con Java 10+ :

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

Nota: tenga mucho cuidado si utiliza una transmisión en paralelo. Es posible que no obtenga el resultado esperado. Otras soluciones como la de Stuart podrían adaptarse mejor a esos casos.

Para tipos distintos a int

Por supuesto, esto sigue siendo válido para tipos distintos de int. Solo necesita cambiar el tipo de envoltura a AtomicReferenceuna matriz de ese tipo. Por ejemplo, si usa a String, simplemente haga lo siguiente:

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

Usa una matriz:

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

O con Java 10+:

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

Esto está bastante cerca de un problema XY . Es decir, la pregunta que se hace es esencialmente cómo mutar una variable local capturada de una lambda. Pero la tarea real que tenemos entre manos es cómo numerar los elementos de una lista.

En mi experiencia, más del 80% de las veces hay una cuestión de cómo mutar un local capturado desde dentro de una lambda, hay una mejor manera de proceder. Por lo general, esto implica una reducción, pero en este caso, la técnica de ejecutar una secuencia sobre los índices de la lista se aplica bien:

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

Si solo necesita pasar el valor desde el exterior a la lambda y no sacarlo, puede hacerlo con una clase anónima regular en lugar de una lambda:

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

Como las variables utilizadas desde fuera de lamda deben ser (implícitamente) finales, debe usar algo como AtomicIntegero escribir su propia estructura de datos.

Consulte https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html#accessing-local-variables .

Si está en Java 10, puede usar varpara eso:

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

Una alternativa a AtomicInteger(o cualquier otro objeto capaz de almacenar un valor) es usar una matriz:

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

Pero vea la respuesta de Stuart : podría haber una mejor manera de lidiar con su caso.

Sé que es una vieja pregunta, pero si se siente cómodo con una solución alternativa, considerando el hecho de que la variable externa debe ser definitiva, simplemente puede hacer esto:

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

Quizás no sea la más elegante, ni siquiera la más correcta, pero servirá.

Puede resumirlo para solucionar el problema del compilador, pero recuerde que no se recomiendan los efectos secundarios en lambdas.

Para citar el javadoc

En general, se desaconsejan los efectos secundarios en los parámetros de comportamiento de las operaciones de transmisión, ya que a menudo pueden conducir a violaciones involuntarias del requisito de apatridia. -efectos; estos deben usarse con cuidado

Tuve un problema ligeramente diferente. En lugar de incrementar una variable local en forEach, necesitaba asignar un objeto a la variable local.

Resolví esto definiendo una clase de dominio interno privado que envuelve tanto la lista sobre la que quiero iterar (countryList) como la salida que espero obtener de esa lista (foundCountry). Luego, usando Java 8 "forEach", itero sobre el campo de lista, y cuando se encuentra el objeto que quiero, asigno ese objeto al campo de salida. Entonces esto asigna un valor a un campo de la variable local, sin cambiar la variable local en sí. Creo que dado que la variable local en sí no se cambia, el compilador no se queja. Luego puedo usar el valor que capturé en el campo de salida, fuera de la lista.

Objeto de dominio:

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

Objeto envoltorio:

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

Operación iterativa:

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());

Puede eliminar el método de la clase contenedora "setCountryList ()" y hacer que el campo "countryList" sea final, pero no obtuve errores de compilación dejando estos detalles como están.

Para tener una solución más general, puede escribir una clase Wrapper genérica:

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

(esta es una variante de la solución dada por Almir Campos).

En el caso específico, esta no es una buena solución, ya que Integeres peor que intpara su propósito, de todos modos esta solución es más general, creo.

Sí, puede modificar las variables locales desde dentro de las lambdas (de la manera que se muestra en las otras respuestas), pero no debe hacerlo. Las lambdas han sido para un estilo funcional de programación y esto significa: Sin efectos secundarios. Lo que quieres hacer se considera de mal estilo. También es peligroso en caso de corrientes paralelas.

Debería encontrar una solución sin efectos secundarios o utilizar un bucle for tradicional.