Modificar uma variável local em forEachdá um erro de compilação:

Normal

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

Com lambda

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

Alguma ideia de como resolver isso?

Use um invólucro

Qualquer tipo de embalagem é bom.

Com o Java 8+ , use AtomicInteger:

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

... ou uma matriz:

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

Com Java 10+ :

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

Nota: tenha muito cuidado se você usar um fluxo paralelo. Você pode não acabar com o resultado esperado. Outras soluções como a de Stuart podem ser mais adaptadas para esses casos.

Para tipos diferentes de int

Claro, isso ainda é válido para tipos diferentes de int. Você só precisa alterar o tipo de embalagem para um AtomicReferenceou uma matriz desse tipo. Por exemplo, se você usar um String, faça o seguinte:

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

Use uma matriz:

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

Ou com Java 10+:

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

Isso é quase um problema XY . Ou seja, a questão que está sendo feita é essencialmente como transformar uma variável local capturada de um lambda. Mas a tarefa real em questão é como numerar os elementos de uma lista.

Na minha experiência, em mais de 80% das vezes, há uma questão de como transformar um local capturado de dentro de um lambda, há uma maneira melhor de proceder. Normalmente, isso envolve redução, mas, neste caso, a técnica de executar um fluxo sobre os índices da lista se aplica bem:

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

Se você só precisa passar o valor de fora para o lambda, e não retirá-lo, pode fazer isso com uma classe anônima regular em vez de um lambda:

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

Como as variáveis ​​usadas de fora do lamda devem ser (implicitamente) finais, você deve usar algo como AtomicIntegerou escrever sua própria estrutura de dados.

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

Se você estiver no Java 10, pode usar varpara isso:

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

Uma alternativa para AtomicInteger(ou qualquer outro objeto capaz de armazenar um valor) é usar uma matriz:

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

Mas veja a resposta do Stuart : pode haver uma maneira melhor de lidar com o seu caso.

Eu sei que é uma pergunta antiga, mas se você se sentir confortável com uma solução alternativa, considerando o fato de que a variável externa deve ser final, você pode simplesmente fazer isto:

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

Talvez não seja o mais elegante, ou mesmo o mais correto, mas servirá.

Você pode embrulhar para contornar o compilador, mas lembre-se de que os efeitos colaterais em lambdas são desencorajados.

Para citar o javadoc

Os efeitos colaterais em parâmetros comportamentais para operações de fluxo são, em geral, desencorajados, pois podem frequentemente levar a violações involuntárias do requisito de apatridia. Um pequeno número de operações de fluxo, como forEach () e peek (), podem operar apenas via lado -efeitos; estes devem ser usados ​​com cuidado

Eu tive um problema um pouco diferente. Em vez de incrementar uma variável local em forEach, precisei atribuir um objeto à variável local.

Resolvi isso definindo uma classe de domínio interno privado que envolve a lista que desejo iterar (countryList) e a saída que espero obter dessa lista (foundCountry). Em seguida, usando Java 8 "forEach", itero sobre o campo de lista e, quando o objeto que desejo é encontrado, atribuo esse objeto ao campo de saída. Portanto, isso atribui um valor a um campo da variável local, não alterando a própria variável local. Acredito que, como a variável local em si não é alterada, o compilador não reclama. Posso então usar o valor que capturei no campo de saída, fora da lista.

Objeto de domínio:

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

Operação de iteração:

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

Você poderia remover o método da classe wrapper "setCountryList ()" e tornar o campo "countryList" final, mas não recebi erros de compilação deixando esses detalhes como estão.

Para ter uma solução mais geral, você pode escrever uma classe 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 é uma variante da solução dada por Almir Campos).

No caso específico esta não é uma boa solução, pois Integeré pior do que intpara o seu propósito, de qualquer forma esta solução é mais geral eu acho.

Sim, você pode modificar variáveis ​​locais de dentro dos lambdas (da maneira mostrada pelas outras respostas), mas você não deve fazer isso. Lambdas são para um estilo funcional de programação e isso significa: Sem efeitos colaterais. O que você quer fazer é considerado um estilo ruim. Também é perigoso no caso de fluxos paralelos.

Você deve encontrar uma solução sem efeitos colaterais ou usar um loop for tradicional.