Gibt es eine präzise Möglichkeit, einen Stream mit Indizes in Java 8 zu durchlaufen?

Gibt es eine übersichtliche Möglichkeit, einen Stream zu durchlaufen, während Sie Zugriff auf den Index im Stream haben?

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

Das scheint ziemlich enttäuschend im Vergleich zu dem dort gegebenen LINQ-Beispiel

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

Gibt es einen prägnanteren Weg?

Weiter scheint es, dass der Reißverschluss entweder bewegt oder entfernt wurde ...

Der sauberste Weg ist, von einem Strom von Indizes auszugehen:

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 nur "Erik".

Eine Alternative , die besser vertraut aussieht , wenn Sie verwendet werden , um für Schleifen würden ein Ad - hoc - Zähler unter Verwendung eines veränderliches Objekt zu halten, 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 die Verwendung der letzteren Methode in einem parallelen Stream unterbrochen werden kann, da die Elemente nicht unbedingt "in der richtigen Reihenfolge" verarbeitet werden müssen .

Der Java 8-Streams-API fehlen die Funktionen zum Abrufen des Index eines Stream-Elements sowie die Möglichkeit, Streams zusammen zu komprimieren. Dies ist bedauerlich, da dadurch bestimmte Anwendungen (wie die LINQ-Herausforderungen) schwieriger werden als sonst.

Es gibt jedoch häufig Problemumgehungen. Normalerweise kann dies erreicht werden, indem der Stream mit einem ganzzahligen Bereich "angesteuert" wird und die Tatsache ausgenutzt wird, dass sich die ursprünglichen Elemente häufig in einem Array oder in einer Sammlung befinden, auf die über den Index zugegriffen werden kann. Zum Beispiel kann das Challenge 2-Problem folgendermaßen gelöst werden:

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

Wie oben erwähnt, nutzt dies die Tatsache aus, dass die Datenquelle (das Namensarray) direkt indizierbar ist. Wenn es nicht wäre, würde diese Technik nicht funktionieren.

Ich gebe zu, dass dies nicht die Absicht von Herausforderung 2 erfüllt. Trotzdem löst es das Problem einigermaßen effektiv.

BEARBEITEN

In meinem vorherigen Codebeispiel wurden flatMapdie Filter- und Kartenoperationen zusammengeführt, dies war jedoch umständlich und bot keinen Vorteil. Ich habe das Beispiel gemäß dem Kommentar von Holger aktualisiert.

Seit Guave 21 können Sie verwenden

Streams.mapWithIndex()

Beispiel (aus dem offiziellen Dokument ):

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

Ich habe in meinem Projekt die folgende Lösung verwendet. Ich denke, es ist besser als veränderbare Objekte oder ganzzahlige Bereiche zu verwenden.

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

Zusätzlich zum Protonpack bietet Seq von jOOλ diese Funktionalität (und durch Erweiterungsbibliotheken, die darauf aufbauen, wie Zyklopen reagieren , bin ich 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.of (Namen) und erstellt einen JDK-Stream unter der Decke.

Das einfach reagierende Äquivalent würde ähnlich aussehen

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

Die einfach reagierende Version ist eher auf asynchrone / gleichzeitige Verarbeitung zugeschnitten.

Der Vollständigkeit halber ist hier die Lösung für meine StreamEx- Bibliothek:

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

Hier erstellen wir eine, EntryStream<Integer, String>die Stream<Entry<Integer, String>>einige spezifische Operationen wie filterKeyValueoder erweitert und hinzufügt values. Es wird auch eine toList()Verknüpfung verwendet.

Ich habe die Lösungen hier gefunden, wenn der Stream aus einer Liste oder einem Array erstellt wird (und Sie die Größe kennen). Aber was ist, wenn Stream eine unbekannte Größe hat? 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);
            }
        };
    }
}

Verwendungszweck:

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

Mit einer Liste können Sie versuchen

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

Ausgabe:

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

Es gibt keine Möglichkeit, über eine Weile zu iterieren, Streamwährend Sie Zugriff auf den Index haben, da a Streamanders ist als alle anderen Collection. A Streamist lediglich eine Pipeline zum Übertragen von Daten von einem Ort zum anderen, wie in der Dokumentation angegeben :

Kein Speicher. Ein Stream ist keine Datenstruktur, in der Elemente gespeichert werden. Stattdessen übertragen sie Werte von einer Quelle (die eine Datenstruktur, ein Generator, ein E / A-Kanal usw. sein kann) durch eine Pipeline von Rechenoperationen.

Natürlich können Sie, wie Sie in Ihrer Frage anscheinend andeuten, Ihre jederzeit Stream<V>in eine konvertieren Collection<V>, z. B. eine List<V>, in der Sie Zugriff auf die Indizes haben.

Mit https://github.com/poetix/protonpack können Sie diese Zip-Datei erstellen:

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

Wenn Sie nichts dagegen haben eine Drittanbieter - Bibliothek, Eclipse - Kollektionen haben zipWithIndexund forEachWithIndexverfügbar für den Einsatz in vielen Arten. Hier finden Sie eine Reihe von Lösungen für diese Herausforderung, die sowohl für JDK-Typen als auch für Eclipse-Sammlungstypen verwendet werden 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, die forEachWithIndexstattdessen verwendet wird.

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 die Lambdas oben in anonyme innere Klassen ändern, funktionieren alle diese Codebeispiele auch in Java 5 - 7.

Hinweis: Ich bin ein Committer für Eclipse-Sammlungen

Wenn Sie zufällig Vavr (früher bekannt als Javaslang) verwenden, können Sie die dedizierte Methode nutzen:

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

Wenn wir den Inhalt ausdrucken, werden wir etwas Interessantes sehen:

Stream((A, 0), ?)

Dies liegt daran, dass Streamswir faul sind und keine Ahnung haben, welche Elemente im Stream als nächstes angezeigt werden.

Wenn Sie versuchen, einen Index basierend auf einem Prädikat zu erhalten, versuchen Sie Folgendes:

Wenn Sie sich nur für den ersten Index interessieren:

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

Oder wenn Sie mehrere Indizes suchen möchten:

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

Fügen .orElse(-1);Sie hinzu, falls Sie einen Wert zurückgeben möchten, wenn er nicht gefunden wird.

Hier ist Code von AbacusUtil

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

Offenlegung: Ich bin der Entwickler von AbacusUtil.

Sie können verwenden IntStream.iterate(), um den Index zu erhalten:

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

Dies funktioniert nur für Java 9 ab Java 8. Sie können Folgendes verwenden:

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

Sie können eine statische innere Klasse erstellen, um den Indexer wie im folgenden Beispiel zu kapseln:

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

Diese Frage ( Stream Way zum Abrufen des Index des ersten Elements, das mit dem Booleschen Wert übereinstimmt ) hat die aktuelle Frage als Duplikat markiert, sodass ich sie dort nicht beantworten kann. Ich beantworte es hier.

Hier ist eine generische Lösung, um den passenden Index zu erhalten, für den keine externe Bibliothek erforderlich ist.

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 nenne es so:

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

Und wenn Sie eine Sammlung verwenden, probieren Sie diese aus.

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

Eine Möglichkeit besteht darin, jedes Element im Flow zu indizieren:

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

Die Verwendung einer anonymen Klasse entlang eines Streams wird nicht gut verwendet, ist aber sehr nützlich.

Sie brauchen nicht zu einem map notwendigerweise
, die am nächsten Lambda zum LINQ Beispiel ist:

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

AUSGABE: 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 

So sammeln Sie in der Liste:

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

Wie jean-baptiste-yunès sagte, wenn Ihr Stream auf einer Java-Liste basiert, ist die Verwendung einer AtomicInteger und ihrer incrementAndGet-Methode eine sehr gute Lösung für das Problem, und die zurückgegebene Ganzzahl entspricht dem Index in der ursprünglichen Liste, solange Sie Verwenden Sie keinen parallelen Stream.

Wenn Sie den Index in forEach benötigen, bietet dies eine Möglichkeit.

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

Verwenden Sie es dann wie folgt.

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