Gibt es eine kurze Form der Iteration über einen stream mit Indizes in Java 8?

Der sauberste Weg ist ein Strom von Indizes:

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

Die resultierende Liste enthält "Erik" nur.

Einer alternative, die sieht eher vertraut, wenn Sie verwendet werden, um for-Schleifen wäre die Aufrechterhaltung einer ad-hoc-Zähler mit ein veränderliches Objekt, zum Beispiel ein 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());

Beachten Sie, dass bei der letzten Methode auf einem parallelen stream brechen könnte, da der Artikel nicht unbedingt verarbeitet werden", um".

InformationsquelleAutor assylias

Seit Guave 21, die Sie verwenden können,

Streams.mapWithIndex()

Beispiel (aus offizielle doc):

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

InformationsquelleAutor numéro6

Neben protonpack, jOOλ s Seq bietet diese Funktionalität (und durch die Erweiterung libraries, die darauf aufbauen, wie cyclops-reagieren, ich bin der Autor dieser Bibliothek).

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

Seq unterstützt auch nur Seq.(Namen) und bauen eine JDK-Stream unter der Decke.

Dem einfach reagieren äquivalent würden ähnlich Aussehen wie

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

Die einfach-version reagieren zugeschnitten für asynchrone /gleichzeitige Verarbeitung.

InformationsquelleAutor John McClean

Fand ich die Lösungen hier, wenn der Stream erstellt, der Liste oder ein array (und Sie wissen, die Größe). Aber was ist, wenn Strom mit unbekannter Größe? In diesem Fall versuchen Sie diese 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);
            }
        };
    }
}

Verwendung:

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

InformationsquelleAutor alex.b

Gibt es nicht eine Möglichkeit zum Durchlaufen eines Stream während mit Zugriff auf den index, weil ein Stream ist anders als alle Collection. Ein Stream ist lediglich eine pipeline für den Transport von Daten von einem Ort zu einem anderen, wie es in der Dokumentation:

Keine Speicherung. Ein stream ist nicht eine Daten-Struktur, die speichert Elemente; stattdessen tragen Sie die Werte aus einer Datenquelle (die könnte eine Datenstruktur, einen generator, einen IO-Kanal usw.) über eine pipeline von Rechenoperationen.

Natürlich, wie Sie zu sein scheinen, anspielend auf Ihre Frage, konnte man immer konvertieren Sie Ihre Stream<V> zu einem Collection<V> wie ein List<V>, in dem Sie haben Zugriff auf die Indizes.

InformationsquelleAutor Josh M

Wenn Sie nichts dagegen haben, mit einem Drittanbieter-Bibliothek, Eclipse-Sammlungen hat zipWithIndex und forEachWithIndex verfügbar für die Verwendung über viele Arten. Hier ist eine Reihe von Lösungen, um diese Herausforderung für beide JDK-Typen und Eclipse Sammlungen Arten mit 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);

Hier ist eine Lösung mit forEachWithIndex statt.

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

Wenn Sie ändern die Lambda-Ausdrücke, anonyme innere Klassen, oben, dann werden alle diese code-Beispiele funktionieren in Java-5 - 7.

Hinweis: ich bin committer für Eclipse Sammlungen

InformationsquelleAutor Donald Raab

Hier ist der code von AbacusUtil

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

Offenlegung： ich bin der Entwickler des AbacusUtil.

InformationsquelleAutor user_3380739

Diese Frage (Stream Weg, um index des ersten Elements, das passende boolean) markiert die aktuelle Frage als Duplikat, so kann ich es nicht beantworten; ich beantworte Sie hier.

Hier ist eine generische Lösung, um die matching-index, die nicht erfordert eine externe Bibliothek.

Wenn Sie eine Liste haben.

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

- Und nennen es wie folgt:

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

Und wenn Sie eine Sammlung, versuchen Sie diese ein.

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

InformationsquelleAutor Steven Spungin

Eine Möglichkeit ist die Indizierung jedes element auf der flow:

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

Mithilfe einer anonymen Klasse, entlang eines Baches, ist nicht gut verwendet werden, während Sie sehr nützlich.

InformationsquelleAutor Jean-Baptiste Yunès