La modifica di una variabile locale in forEachdà un errore di compilazione:

Normale

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

Con Lambda

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

Qualche idea su come risolvere questo problema?

Usa un involucro

Qualsiasi tipo di involucro va bene.

Con Java 8+ , utilizza uno dei seguenti AtomicInteger:

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

... o un array:

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: fai molta attenzione se utilizzi un flusso parallelo. Potresti non ottenere il risultato atteso. Altre soluzioni come quella di Stuart potrebbero essere più adatte a questi casi.

Per tipi diversi da int

Naturalmente, questo è ancora valido per i tipi diversi da int. Hai solo bisogno di cambiare il tipo di wrapping in un AtomicReferenceo un array di quel tipo. Ad esempio, se utilizzi a String, procedi come segue:

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

Usa un array:

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

Questo è abbastanza vicino a un problema XY . Cioè, la domanda che viene posta è essenzialmente come mutare una variabile locale catturata da un lambda. Ma il vero compito a portata di mano è come numerare gli elementi di un elenco.

Nella mia esperienza, fino all'80% delle volte c'è una domanda su come mutare un locale catturato dall'interno di un lambda, c'è un modo migliore per procedere. Di solito ciò comporta la riduzione, ma in questo caso si applica bene la tecnica di eseguire un flusso sugli indici della lista:

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

Se hai solo bisogno di passare il valore dall'esterno nel lambda e non farlo uscire, puoi farlo con una normale classe anonima invece di un lambda:

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

Poiché le variabili usate dall'esterno della lamda devono essere (implicitamente) finali, devi usare qualcosa di simile AtomicIntegero scrivere la tua struttura dati.

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

Se sei su Java 10, puoi usare varper quello:

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

Un'alternativa a AtomicInteger(oa qualsiasi altro oggetto in grado di memorizzare un valore) è usare un array:

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

Ma guarda la risposta di Stuart : potrebbe esserci un modo migliore per affrontare il tuo caso.

So che è una vecchia domanda, ma se ti senti a tuo agio con una soluzione alternativa, considerando il fatto che la variabile esterna dovrebbe essere definitiva, puoi semplicemente farlo:

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

Forse non il più elegante, o anche il più corretto, ma andrà bene.

Puoi avvolgerlo per aggirare il compilatore, ma ricorda che gli effetti collaterali nei lambda sono scoraggiati.

Per citare il javadoc

Gli effetti collaterali nei parametri comportamentali per le operazioni di streaming sono, in generale, scoraggiati, poiché spesso possono portare a violazioni inconsapevoli del requisito di apolidia Un piccolo numero di operazioni di flusso, come forEach () e peek (), può operare solo tramite -Effetti; questi dovrebbero essere usati con attenzione

Ho avuto un problema leggermente diverso. Invece di incrementare una variabile locale in forEach, avevo bisogno di assegnare un oggetto alla variabile locale.

Ho risolto questo problema definendo una classe di dominio interno privato che racchiude sia l'elenco su cui desidero iterare (countryList) sia l'output che spero di ottenere da tale elenco (foundCountry). Quindi, utilizzando Java 8 "forEach", itero sul campo elenco e quando viene trovato l'oggetto che desidero, assegno quell'oggetto al campo di output. Quindi questo assegna un valore a un campo della variabile locale, senza modificare la variabile locale stessa. Credo che poiché la variabile locale stessa non viene modificata, il compilatore non si lamenta. Posso quindi utilizzare il valore che ho catturato nel campo di output, al di fuori dell'elenco.

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

Oggetto wrapper:

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

Operazione ripetuta:

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

Potresti rimuovere il metodo della classe wrapper "setCountryList ()" e rendere finale il campo "countryList", ma non ho ricevuto errori di compilazione lasciando questi dettagli così come sono.

Per avere una soluzione più generale, puoi scrivere una classe Wrapper generica:

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

(questa è una variante della soluzione data da Almir Campos).

Nel caso specifico questa non è una buona soluzione, in quanto Integerè peggio che intper il tuo scopo, comunque questa soluzione credo sia più generale.

Sì, puoi modificare le variabili locali dall'interno dei lambda (nel modo mostrato dalle altre risposte), ma non dovresti farlo. I Lambda sono stati per uno stile di programmazione funzionale e questo significa: Nessun effetto collaterale. Quello che vuoi fare è considerato un cattivo stile. È anche pericoloso in caso di flussi paralleli.

Dovresti trovare una soluzione senza effetti collaterali o utilizzare un ciclo for tradizionale.