Modyfikacja zmiennej lokalnej w programie forEachpowoduje błąd kompilacji:

Normalna

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

Z Lambda

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

Masz jakiś pomysł, jak to rozwiązać?

Użyj opakowania

Każdy rodzaj opakowania jest dobry.

W przypadku języka Java 8+ użyj AtomicInteger:

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

... lub tablica:

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

Z Javą 10+ :

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

Uwaga: zachowaj ostrożność, jeśli używasz strumienia równoległego. Możesz nie osiągnąć oczekiwanego rezultatu. Inne rozwiązania, takie jak Stuart, mogą być lepiej dostosowane do tych przypadków.

Dla typów innych niż int

Oczywiście jest to nadal ważne dla typów innych niż int. Musisz tylko zmienić typ zawijania na AtomicReferencetablicę lub tablicę tego typu. Na przykład, jeśli używasz a String, po prostu wykonaj następujące czynności:

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

Użyj tablicy:

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

Lub z Javą 10+:

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

Jest to dość bliskie problemowi XY . Oznacza to, że zasadniczo zadaje się pytanie, jak zmutować przechwyconą zmienną lokalną z lambda. Ale aktualnym zadaniem jest numerowanie elementów listy.

Z mojego doświadczenia wynika, że ​​w 80% przypadków w górę pojawia się pytanie, jak zmutować przechwycony lokalnie z wnętrza lambda, jest lepszy sposób postępowania. Zwykle wiąże się to z redukcją, ale w tym przypadku technika prowadzenia strumienia po indeksach list ma zastosowanie:

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

Jeśli potrzebujesz tylko przekazać wartość z zewnątrz do lambda, a nie ją wyciągać, możesz to zrobić za pomocą zwykłej klasy anonimowej zamiast lambdy:

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

Ponieważ użyte zmienne spoza lamdy muszą być (niejawnie) ostateczne, musisz użyć czegoś podobnego AtomicIntegerlub napisać własną strukturę danych.

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

Jeśli korzystasz z Java 10, możesz użyć vardo tego:

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

Alternatywą dla AtomicInteger(lub dowolnego innego obiektu, który może przechowywać wartość) jest użycie tablicy:

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

Ale spójrz na odpowiedź Stuarta : może być lepszy sposób na załatwienie sprawy.

Wiem, że to stare pytanie, ale jeśli nie masz nic przeciwko obejściu, biorąc pod uwagę fakt, że zmienna zewnętrzna powinna być ostateczna, możesz po prostu zrobić to:

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

Może nie jest to najbardziej eleganckie, a nawet najbardziej poprawne, ale wystarczy.

Możesz to zakończyć, aby obejść kompilator, ale pamiętaj, że efekty uboczne w lambdach są odradzane.

Cytując plik javadoc

Skutki uboczne parametrów behawioralnych operacji strumieniowych są generalnie odradzane, ponieważ często mogą prowadzić do nieświadomego naruszenia wymogu bezpaństwowości Niewielka liczba operacji na strumieniu, takich jak forEach () i peek (), może działać tylko z boku -efekty; należy ich używać ostrożnie

Miałem nieco inny problem. Zamiast zwiększać lokalną zmienną w forEach, musiałem przypisać obiekt do zmiennej lokalnej.

Rozwiązałem to, definiując prywatną klasę domeny wewnętrznej, która otacza zarówno listę, którą chcę iterować (countryList), jak i dane wyjściowe, które mam nadzieję uzyskać z tej listy (foundCountry). Następnie używając Java 8 „forEach”, iteruję po polu listy, a kiedy szukany obiekt zostanie znaleziony, przypisuję ten obiekt do pola wyjściowego. Więc to przypisuje wartość do pola zmiennej lokalnej, nie zmieniając samej zmiennej lokalnej. Uważam, że skoro sama zmienna lokalna nie jest zmieniana, kompilator nie narzeka. Następnie mogę użyć wartości, którą przechwyciłem w polu wyjściowym, poza listą.

Obiekt domeny:

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

Obiekt opakowania:

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

Operacja iteracyjna:

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

Możesz usunąć metodę klasy opakowania „setCountryList ()” i nadać polu „countryList” ostateczną wartość, ale nie otrzymałem błędów kompilacji, pozostawiając te szczegóły bez zmian.

Aby mieć bardziej ogólne rozwiązanie, możesz napisać ogólną klasę 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++;
});

(jest to wariant rozwiązania podany przez Almira Camposa).

W konkretnym przypadku nie jest to dobre rozwiązanie, ponieważ Integerjest gorsze niż intw twoim celu, zresztą to rozwiązanie jest bardziej ogólne.

Tak, możesz modyfikować zmienne lokalne z wnętrza lambd (w sposób pokazany przez inne odpowiedzi), ale nie powinieneś tego robić. Lambdy zostały stworzone dla funkcjonalnego stylu programowania, co oznacza: Brak efektów ubocznych. To, co chcesz robić, jest uważane za zły styl. Jest to również niebezpieczne w przypadku strumieni równoległych.

Powinieneś albo znaleźć rozwiązanie bez skutków ubocznych, albo użyć tradycyjnej pętli for.