Existe uma maneira concisa de iterar em um fluxo com índices no Java 8?

Existe uma maneira concisa de iterar em um fluxo enquanto tiver acesso ao índice no fluxo?

String[] names = {"Sam","Pamela", "Dave", "Pascal", "Erik"};

List<String> nameList;
Stream<Integer> indices = intRange(1, names.length).boxed();
nameList = zip(indices, stream(names), SimpleEntry::new)
        .filter(e -> e.getValue().length() <= e.getKey())
        .map(Entry::getValue)
        .collect(toList());

o que parece bastante decepcionante em comparação com o exemplo LINQ dado lá

string[] names = { "Sam", "Pamela", "Dave", "Pascal", "Erik" };
var nameList = names.Where((c, index) => c.Length <= index + 1).ToList();

Existe uma maneira mais concisa?

Além disso, parece que o zip foi movido ou removido ...

A maneira mais limpa é começar a partir de um fluxo de índices:

String[] names = {"Sam", "Pamela", "Dave", "Pascal", "Erik"};
IntStream.range(0, names.length)
         .filter(i -> names[i].length() <= i)
         .mapToObj(i -> names[i])
         .collect(Collectors.toList());

A lista resultante contém apenas "Erik".

Uma alternativa que parece mais familiar quando você está acostumado a fazer loops seria manter um contador ad hoc usando um objeto mutável, por exemplo AtomicInteger:

String[] names = {"Sam", "Pamela", "Dave", "Pascal", "Erik"};
AtomicInteger index = new AtomicInteger();
List<String> list = Arrays.stream(names)
                          .filter(n -> n.length() <= index.incrementAndGet())
                          .collect(Collectors.toList());

Observe que o uso do último método em um fluxo paralelo pode ser interrompido, pois os itens não são necessariamente processados ​​"em ordem" .

A API de fluxos Java 8 não possui os recursos para obter o índice de um elemento de fluxo, bem como a capacidade de compactar fluxos juntos. Isso é lamentável, pois torna certos aplicativos (como os desafios do LINQ) mais difíceis do que seriam.

No entanto, geralmente existem soluções alternativas. Geralmente, isso pode ser feito "direcionando" o fluxo com um intervalo inteiro e aproveitando o fato de que os elementos originais geralmente estão em uma matriz ou em uma coleção acessível por índice. Por exemplo, o problema do Desafio 2 pode ser resolvido desta maneira:

String[] names = {"Sam", "Pamela", "Dave", "Pascal", "Erik"};

List<String> nameList =
    IntStream.range(0, names.length)
        .filter(i -> names[i].length() <= i)
        .mapToObj(i -> names[i])
        .collect(toList());

Como mencionei acima, isso tira proveito do fato de que a fonte de dados (a matriz de nomes) é diretamente indexável. Se não fosse, essa técnica não funcionaria.

Admito que isso não satisfaz a intenção do Desafio 2. No entanto, resolve o problema de maneira razoavelmente eficaz.

EDITAR

Meu exemplo de código anterior costumava flatMapfundir as operações de filtro e mapa, mas isso era complicado e não oferecia vantagem. Eu atualizei o exemplo pelo comentário de Holger.

Desde a goiaba 21, você pode usar

Streams.mapWithIndex()

Exemplo (do documento oficial ):

Streams.mapWithIndex(
    Stream.of("a", "b", "c"),
    (str, index) -> str + ":" + index)
) // will return Stream.of("a:0", "b:1", "c:2")

Eu usei a seguinte solução no meu projeto. Eu acho que é melhor do que usar objetos mutáveis ​​ou intervalos inteiros.

import java.util.*;
import java.util.function.*;
import java.util.stream.Collector;
import java.util.stream.Collector.Characteristics;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
import static java.util.Objects.requireNonNull;


public class CollectionUtils {
    private CollectionUtils() { }

    /**
     * Converts an {@link java.util.Iterator} to {@link java.util.stream.Stream}.
     */
    public static <T> Stream<T> iterate(Iterator<? extends T> iterator) {
        int characteristics = Spliterator.ORDERED | Spliterator.IMMUTABLE;
        return StreamSupport.stream(Spliterators.spliteratorUnknownSize(iterator, characteristics), false);
    }

    /**
     * Zips the specified stream with its indices.
     */
    public static <T> Stream<Map.Entry<Integer, T>> zipWithIndex(Stream<? extends T> stream) {
        return iterate(new Iterator<Map.Entry<Integer, T>>() {
            private final Iterator<? extends T> streamIterator = stream.iterator();
            private int index = 0;

            @Override
            public boolean hasNext() {
                return streamIterator.hasNext();
            }

            @Override
            public Map.Entry<Integer, T> next() {
                return new AbstractMap.SimpleImmutableEntry<>(index++, streamIterator.next());
            }
        });
    }

    /**
     * Returns a stream consisting of the results of applying the given two-arguments function to the elements of this stream.
     * The first argument of the function is the element index and the second one - the element value. 
     */
    public static <T, R> Stream<R> mapWithIndex(Stream<? extends T> stream, BiFunction<Integer, ? super T, ? extends R> mapper) {
        return zipWithIndex(stream).map(entry -> mapper.apply(entry.getKey(), entry.getValue()));
    }

    public static void main(String[] args) {
        String[] names = {"Sam", "Pamela", "Dave", "Pascal", "Erik"};

        System.out.println("Test zipWithIndex");
        zipWithIndex(Arrays.stream(names)).forEach(entry -> System.out.println(entry));

        System.out.println();
        System.out.println("Test mapWithIndex");
        mapWithIndex(Arrays.stream(names), (Integer index, String name) -> index+"="+name).forEach((String s) -> System.out.println(s));
    }
}

Além do protonpack, o Seq do jOOλ fornece essa funcionalidade (e por bibliotecas de extensão que o compõem como cyclops-react , eu sou o autor desta biblioteca).

Seq.seq(Stream.of(names)).zipWithIndex()
                         .filter( namesWithIndex -> namesWithIndex.v1.length() <= namesWithIndex.v2 + 1)
                         .toList();

O Seq também suporta apenas o Seq.of (nomes) e criará um JDK Stream sob as cobertas.

O equivalente de reação simples seria semelhante a

 LazyFutureStream.of(names)
                 .zipWithIndex()
                 .filter( namesWithIndex -> namesWithIndex.v1.length() <= namesWithIndex.v2 + 1)
                 .toList();

A versão de reação simples é mais personalizada para processamento assíncrono / simultâneo.

Apenas para completar, aqui está a solução que envolve minha biblioteca StreamEx :

String[] names = {"Sam","Pamela", "Dave", "Pascal", "Erik"};
EntryStream.of(names)
    .filterKeyValue((idx, str) -> str.length() <= idx+1)
    .values().toList();

Aqui criamos um EntryStream<Integer, String>que estende Stream<Entry<Integer, String>>e adiciona algumas operações específicas como filterKeyValueou values. Também toList()é usado um atalho.

Encontrei as soluções aqui quando o Stream é criado de lista ou matriz (e você sabe o tamanho). Mas e se o Stream tiver tamanho desconhecido? Nesse caso, tente esta variante:

public class WithIndex<T> {
    private int index;
    private T value;

    WithIndex(int index, T value) {
        this.index = index;
        this.value = value;
    }

    public int index() {
        return index;
    }

    public T value() {
        return value;
    }

    @Override
    public String toString() {
        return value + "(" + index + ")";
    }

    public static <T> Function<T, WithIndex<T>> indexed() {
        return new Function<T, WithIndex<T>>() {
            int index = 0;
            @Override
            public WithIndex<T> apply(T t) {
                return new WithIndex<>(index++, t);
            }
        };
    }
}

Uso:

public static void main(String[] args) {
    Stream<String> stream = Stream.of("a", "b", "c", "d", "e");
    stream.map(WithIndex.indexed()).forEachOrdered(e -> {
        System.out.println(e.index() + " -> " + e.value());
    });
}

Com uma lista, você pode tentar

List<String> strings = new ArrayList<>(Arrays.asList("First", "Second", "Third", "Fourth", "Fifth")); // An example list of Strings
strings.stream() // Turn the list into a Stream
    .collect(HashMap::new, (h, o) -> h.put(h.size(), o), (h, o) -> {}) // Create a map of the index to the object
        .forEach((i, o) -> { // Now we can use a BiConsumer forEach!
            System.out.println(String.format("%d => %s", i, o));
        });

Resultado:

0 => First
1 => Second
2 => Third
3 => Fourth
4 => Fifth

Não há uma maneira de iterar durante um Streamtempo tendo acesso ao índice porque a Streamé diferente de qualquer outro Collection. A Streamé apenas um pipeline para transportar dados de um lugar para outro, conforme declarado na documentação :

Nenhum armazenamento. Um fluxo não é uma estrutura de dados que armazena elementos; em vez disso, eles carregam valores de uma fonte (que pode ser uma estrutura de dados, um gerador, um canal de IO etc.) através de um pipeline de operações computacionais.

Obviamente, como você parece sugerir na sua pergunta, você sempre pode convertê-lo Stream<V>em um Collection<V>, como um List<V>, no qual você terá acesso aos índices.

Com https://github.com/poetix/protonpack, você pode fazer isso:

String[] names = {"Sam","Pamela", "Dave", "Pascal", "Erik"};

List<String> nameList;
Stream<Integer> indices = IntStream.range(0, names.length).boxed(); 

nameList = StreamUtils.zip(indices, stream(names),SimpleEntry::new)
        .filter(e -> e.getValue().length() <= e.getKey()).map(Entry::getValue).collect(toList());                   

System.out.println(nameList);

Se você não se importa em usar uma biblioteca de terceiros, o Eclipse Collections tem zipWithIndexe está forEachWithIndexdisponível para uso em vários tipos. Aqui está um conjunto de soluções para esse desafio para os tipos JDK e Eclipse Collections usando zipWithIndex.

String[] names = { "Sam", "Pamela", "Dave", "Pascal", "Erik" };
ImmutableList<String> expected = Lists.immutable.with("Erik");
Predicate<Pair<String, Integer>> predicate =
    pair -> pair.getOne().length() <= pair.getTwo() + 1;

// JDK Types
List<String> strings1 = ArrayIterate.zipWithIndex(names)
    .collectIf(predicate, Pair::getOne);
Assert.assertEquals(expected, strings1);

List<String> list = Arrays.asList(names);
List<String> strings2 = ListAdapter.adapt(list)
    .zipWithIndex()
    .collectIf(predicate, Pair::getOne);
Assert.assertEquals(expected, strings2);

// Eclipse Collections types
MutableList<String> mutableNames = Lists.mutable.with(names);
MutableList<String> strings3 = mutableNames.zipWithIndex()
    .collectIf(predicate, Pair::getOne);
Assert.assertEquals(expected, strings3);

ImmutableList<String> immutableNames = Lists.immutable.with(names);
ImmutableList<String> strings4 = immutableNames.zipWithIndex()
    .collectIf(predicate, Pair::getOne);
Assert.assertEquals(expected, strings4);

MutableList<String> strings5 = mutableNames.asLazy()
    .zipWithIndex()
    .collectIf(predicate, Pair::getOne, Lists.mutable.empty());
Assert.assertEquals(expected, strings5);

Aqui está uma solução usando em seu forEachWithIndexlugar.

MutableList<String> mutableNames =
    Lists.mutable.with("Sam", "Pamela", "Dave", "Pascal", "Erik");
ImmutableList<String> expected = Lists.immutable.with("Erik");

List<String> actual = Lists.mutable.empty();
mutableNames.forEachWithIndex((name, index) -> {
        if (name.length() <= index + 1)
            actual.add(name);
    });
Assert.assertEquals(expected, actual);

Se você alterar as lambdas para classes internas anônimas acima, todos esses exemplos de código também funcionarão no Java 5 - 7.

Nota: Eu sou um confirmador das Coleções Eclipse

Se você usar o Vavr (anteriormente conhecido como Javaslang), poderá aproveitar o método dedicado:

Stream.of("A", "B", "C")
  .zipWithIndex();

Se imprimirmos o conteúdo, veremos algo interessante:

Stream((A, 0), ?)

Isso ocorre porque Streamssão preguiçosos e não temos idéia dos próximos itens no fluxo.

Se você está tentando obter um índice com base em um predicado, tente o seguinte:

Se você se importa apenas com o primeiro índice:

OptionalInt index = IntStream.range(0, list.size())
    .filter(i -> list.get(i) == 3)
    .findFirst();

Ou se você deseja encontrar vários índices:

IntStream.range(0, list.size())
   .filter(i -> list.get(i) == 3)
   .collect(Collectors.toList());

Adicione .orElse(-1);no caso de você querer retornar um valor se ele não o encontrar.

Aqui está o código de AbacusUtil

Stream.of(names).indexed()
      .filter(e -> e.value().length() <= e.index())
      .map(Indexed::value).toList();

Divulgação: sou o desenvolvedor do AbacusUtil.

Você pode usar IntStream.iterate()para obter o índice:

String[] names = {"Sam","Pamela", "Dave", "Pascal", "Erik"};
List<String> nameList = IntStream.iterate(0, i -> i < names.length, i -> i + 1)
        .filter(i -> names[i].length() <= i)
        .mapToObj(i -> names[i])
        .collect(Collectors.toList());

Isso funciona apenas para o Java 9 para cima no Java 8, você pode usar isto:

String[] names = {"Sam","Pamela", "Dave", "Pascal", "Erik"};
List<String> nameList = IntStream.iterate(0, i -> i + 1)
        .limit(names.length)
        .filter(i -> names[i].length() <= i)
        .mapToObj(i -> names[i])
        .collect(Collectors.toList());

Você pode criar uma classe interna estática para encapsular o indexador, como eu precisava fazer no exemplo abaixo:

static class Indexer {
    int i = 0;
}

public static String getRegex() {
    EnumSet<MeasureUnit> range = EnumSet.allOf(MeasureUnit.class);
    StringBuilder sb = new StringBuilder();
    Indexer indexer = new Indexer();
    range.stream().forEach(
            measureUnit -> {
                sb.append(measureUnit.acronym);
                if (indexer.i < range.size() - 1)
                    sb.append("|");

                indexer.i++;
            }
    );
    return sb.toString();
}

Esta questão ( Stream Way para obter o índice do primeiro elemento correspondente a booleano ) marcou a pergunta atual como duplicada, por isso não posso respondê-la; Eu estou respondendo aqui.

Aqui está uma solução genérica para obter o índice correspondente que não requer uma biblioteca externa.

Se você tem uma lista.

public static <T> int indexOf(List<T> items, Predicate<T> matches) {
        return IntStream.range(0, items.size())
                .filter(index -> matches.test(items.get(index)))
                .findFirst().orElse(-1);
}

E chame assim:

int index = indexOf(myList, item->item.getId()==100);

E se estiver usando uma coleção, tente esta.

   public static <T> int indexOf(Collection<T> items, Predicate<T> matches) {
        int index = -1;
        Iterator<T> it = items.iterator();
        while (it.hasNext()) {
            index++;
            if (matches.test(it.next())) {
                return index;
            }
        }
        return -1;
    }

Uma maneira possível é indexar cada elemento no fluxo:

AtomicInteger index = new AtomicInteger();
Stream.of(names)
  .map(e->new Object() { String n=e; public i=index.getAndIncrement(); })
  .filter(o->o.n.length()<=o.i) // or do whatever you want with pairs...
  .forEach(o->System.out.println("idx:"+o.i+" nam:"+o.n));

O uso de uma classe anônima ao longo de um fluxo não é bem utilizado, sendo muito útil.

você não precisa map necessariamente de um
lambda mais próximo do exemplo LINQ:

int[] idx = new int[] { 0 };
Stream.of( names ).filter( name -> name.length() <= idx[0]++ ).collect( Collectors.toList() );

String[] namesArray = {"Sam","Pamela", "Dave", "Pascal", "Erik"};
String completeString
         =  IntStream.range(0,namesArray.length)
           .mapToObj(i -> namesArray[i]) // Converting each array element into Object
           .map(String::valueOf) // Converting object to String again
           .collect(Collectors.joining(",")); // getting a Concat String of all values
        System.out.println(completeString);

SAÍDA: Sam, Pamela, Dave, Pascal, Erik

String[] namesArray = {"Sam","Pamela", "Dave", "Pascal", "Erik"};

IntStream.range(0,namesArray.length)
               .mapToObj(i -> namesArray[i]) // Converting each array element into Object
               .map(String::valueOf) // Converting object to String again
               .forEach(s -> {
                //You can do various operation on each element here
                System.out.println(s);
               }); // getting a Concat String of all 

Para coletar na lista:

String[] namesArray = {"Sam","Pamela", "Dave", "Pascal", "Erik"};
 List<String> namesList
                =  IntStream.range(0,namesArray.length)
                .mapToObj(i -> namesArray[i]) // Converting each array element into Object
                .map(String::valueOf) // Converting object to String again
                .collect(Collectors.toList()); // collecting elements in List
        System.out.println(listWithIndex);

Como jean-baptiste-yunès disse, se o seu fluxo for baseado em uma lista java, usar um AtomicInteger e seu método incrementAndGet é uma solução muito boa para o problema e o número inteiro retornado corresponde ao índice na lista original, desde que você não use um fluxo paralelo.

Se você precisar do índice no forEach, isso fornece uma maneira.

  public class IndexedValue {

    private final int    index;
    private final Object value;

    public IndexedValue(final int index, final Object value) { 
        this.index = index;
        this.value = value;
    }

    public int getIndex() {
        return index;
    }

    public Object getValue() {
        return value;
    }
}

Em seguida, use-o da seguinte maneira.

@Test
public void withIndex() {
    final List<String> list = Arrays.asList("a", "b");
    IntStream.range(0, list.size())
             .mapToObj(index -> new IndexedValue(index, list.get(index)))
             .forEach(indexValue -> {
                 System.out.println(String.format("%d, %s",
                                                  indexValue.getIndex(),
                                                  indexValue.getValue().toString()));
             });
}