Java 8 Streams: Wie vergleichen Sie aktuelle element mit dem nächsten element?

Wie man das nächste element aus einer List mit Java-8-Streams?

Wenn ich mich Iteration über eine List möchte ich einen Vergleich von aktuellen mit dem nächsten element der Liste.

Ist es machbar, die mit Java 8 Stream?

Iterieren-wie? Wie bestimmen Sie den aktuellen und den nächsten Elementen? Warum fühlen Sie die Notwendigkeit, dies zu tun mit streams?
Was ist Ihr Ziel?
mein Ziel ist es den Vergleich von zwei aufeinanderfolgenden element in der Liste, oder vielleicht will ich überprüfen ob Sie gleich sind.
Das ist eine Aufgabe, kein Ziel. Es muss einen Grund, warum Sie dies tun. E. g. Sie möchten etwas tun, wenn zwei Elemente gleich sind. Was interessant ist, wie zu tun, dass etwas mit streams. Die Frage ist, hat schon gefragt worden, in ähnlichen Formen.

InformationsquelleAutor bhupen | 2015-11-14

13

Meine freie StreamEx - Bibliothek ermöglicht es Ihnen, die Paare von der stream-Elemente mit zusätzlichen pairMap intermediate operation. Wie diese:
```
StreamEx.of(input).pairMap((current, next) -> doSomethingWith(current, next));
```
Wo input ist ein Collection -, array-oder Stream. Zum Beispiel, auf diese Weise können Sie leicht überprüfen, ob die Eingabe sortiert ist:
```
boolean isSorted = StreamEx.of(input)
                           .pairMap((current, next) -> next.compareTo(current))
                           .allMatch(cmp -> cmp >= 0);
```
Gibt es auch forPairs terminal-Betrieb ist ein forEach analog zu allen Paaren von Eingabe-Elemente:
```
StreamEx.of(input).forPairs((current, next) -> doSomethingWith(current, next));
```
Diese features funktionieren sehr gut mit jedem stream source (entweder random access oder nicht) gibt, und unterstützen uneingeschränkt die parallele streams.
- toll. Dank für die Erklärung.
InformationsquelleAutor Tagir Valeev
10

Eine Möglichkeit ist das erzeugen einer IntStream der Indizes, und Holen Sie sich das List - Elementen anhand Ihres index. Dies ist nur dann effizient, wenn der List unterstützt random-access - (d.h. wenn Ihr List ist ein LinkedList, es wäre eine schlechte Idee, da list.get(i) nicht Konstante Zeit).

Beispiel :
```
IntStream.range(0,list.size()-1).forEach(i -> {
    doSomething(list.get(i),list.get(i+1));
});
```
Weitere Möglichkeit ist die Speicherung des letzten Elements in einem array :
```
List<Element> list = ...
Element[] arr = new Element[1];
list.stream().forEach(e -> {
    if (arr[0] != null)
        doSomething(arr[0],e); 
    arr[0]=e;
});
```
Dies funktioniert nur für sequentielle streams.

InformationsquelleAutor Eran
2

Stream.reduzieren könnte verwendet werden, je nach Ziel. Als Sie sagte, Sie möchte den Vergleich von aufeinander folgenden Elementen, die folgende "print " 3":
```
Stream.of(1,2,3,3).reduce((a,b)->{
    if(a==b) System.out.println("Same "+a);
    return b; //will be "a" for next reduction
});
```
- Ein Beispiel mag helfen 🙂
InformationsquelleAutor Marc Dzaebel
0

Machen Sie immer eine der folgenden:
1. Konvertieren stream einen stream von Elementen, die "Geschichte" der letzten Elemente der stream -
2. Prozess Ihr stream in einer Weise, dass die aktuell bearbeitete element wird als "Nächstes" - element und den zuvor bearbeiteten Elements gilt als die "aktuellen" element.
Implementierungen der beiden Lösungen kann man in diesem thread: Ist es möglich, das nächste element in den Stream???

InformationsquelleAutor walkeros

Ich hatte das gleiche zu tun, und vergleichen Sie die Unterschiede der Elemente eines Streams (ursprünglich ein array).
So benutzte ich eine Methode, die als parameter der UnaryOperator, dass .map() erwartet als folgt...und es funktionierte für mich ohne Besondere gizmo:

import java.util.Arrays;

class streamDiffUtil {
    public static void main(String[] args) {
        int[] elements = {1,2,5};
        int result = Arrays.stream(elements)
                .map(value -> calcMaxDiff(value, elements))
                .max()
                .getAsInt();
        System.out.println(result);
    }

    private static int calcMaxDiff(int j, int[] elements) {
        return Arrays.stream(elements)
                .map(value -> Math.abs(j-value))
                .max().getAsInt();
    }
}

Was schön wäre, ist zu wissen, wie die Methode calcMaxDiff entspricht einem UnaryIntOperator in der .anzeigen-Signatur. Das ist ein wenig über mich.
Hoffe, dies hilft Ihnen.

InformationsquelleAutor Beezer

Wenn Sie hatte eine Liste von Integer-zahlen beispielsweise und wollte überprüfen, ob Sie aufsteigend sortiert, könnte man das wie folgt tun:

@Test
public void test_listIsSorted() {

    //create integer list for testing purposes: 0,1,2,3, .., 10
    List<Integer> integerList = IntStream.range(0, 10)
            .boxed()
            .collect(Collectors.toList());

    //stream list and compare item n with n+1
    integerList.stream()
            .reduce((integer1, integer2) -> {
                assert integer1 < integer2 : "ordering must be ascending";
                //return second value (which will be processed as "integer1" in the next iteration
                return integer2;
            });

}

Diese vergleichen Paare wie: (0,1),(1,2),...

InformationsquelleAutor Georg Moser

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.