Kommissionierung Elemente einer Liste, bis die Bedingung erfüllt ist mit Java 8-Lambdas

Ich versuche, um meine Meinung zu glauben, dass die funktionelle Art und Weise und vor kurzem konfrontiert, eine situation, in die ich brauchte, um abholen Elemente aus einer Liste aus, bis eine Bedingung erfüllt ist, und ich konnte nicht finden einen einfachen, natürlichen Weg, dies zu erreichen. Offensichtlich bin ich immer noch lernen.

Sagen, dass ich diese Liste:

List<String> tokens = Arrays.asList("pick me", "Pick me", "pick Me",
    "PICK ME", "pick me and STOP", "pick me", "pick me and Stop", "pick me");

//In a non lambdas was you would do it like below
List<String> myTokens = new ArrayList<>();
for (String token : tokens) {
    myTokens.add(token);
    if (token.toUpperCase().endsWith("STOP")) {
        break;
    }
}

Vielen Dank im Voraus für Eure inputs

HINWEIS:
Vor der Veröffentlichung dieses lese ich Limit ein Strom durch ein Prädikat, aber ich konnte nicht sehen, wie ich das anpassen kann, dass die Antwort auf mein problem. Jede Hilfe wäre geschätzt danke.

Ich habe gelesen, dass die Frage vorher veröffentlichte ich meine, aber ich dachte und denke immer noch, dass java würde einiges aus der box, dies zu erreichen. Etwas sagen wie myTokens = tokens.stream().collect(toListWhile(...)) Oder eine schöne und einfache Möglichkeit für die Umsetzung toListWhile() benutzerdefinierte collector
Ich glaube nicht, dass es ein einzelner Betrieb in die Streams API, die würden davon ausgehen, geordneter Strom, und nicht für eine ungeordnete einem. So ist Ihr Betrieb vorstellen.
mögliche Duplikate von Limit ein Strom durch ein Prädikat
Dies ist nicht eine exakte Kopie, wie hier der OP will das STOP-element als auch. Es ist ein etwas anderes problem.
takeWhile ist eigentlich so etwas wie dieses. JavaDoc-statement für ungeordnete streams ist besonders schön! Eine beliebige Teilmenge, sic! Meiner Meinung nach wäre es wirklich besser, wenn er eine exception wirft...
Ah, also sind Sie wieder hinzufügen---viele, wenn diese waren geplant, vor dem release von Java 8, aber dann fallen gelassen. Java hat in der Regel fail-fast-Semantik im Gegensatz zu GIGO. Dies ist sicher zum generieren einer Menge von sprachlos, SO Fragen.
Es ist eine gute und interessante Frage, aber ich Stimme nicht mit seiner Prämisse. Ich glaube nicht, dass streams sind inteded verwendet werden, für das, was Sie versuchen, Sie zu benutzen. Vor allem, weil Ihr Betrieb hängt von den stream bestellt und, höchstwahrscheinlich, nicht parallelisiert. Was ich denke, Sie tun sollten, ist manuell (stream-weniger) bauen Sie eine gültige Sammlung und dann zu streamen, um es zu verarbeiten.

InformationsquelleAutor Julian | 2015-08-29

1

Einer option verwendet einen Sammler, so daß zwei Funktionen, fügt strings Listen und anderen Listen kombiniert, die zuvor möglicherweise parallel angelegt. Für jedes it-fügt die Zeichenkette oder die gesamte Liste nur, wenn die Vorherige partielle Ausgabe endet nicht mit einem element endet mit STOP:
```
tokens.stream().collect(() -> new ArrayList<String>(), (l, e) -> {
    if(l.isEmpty() || !l.get(l.size()-1).toUpperCase().endsWith("STOP"))
        l.add(e);
}, (l1, l2) -> {
    if(l1.isEmpty() || !l1.get(l1.size()-1).toUpperCase().endsWith("STOP"))
        l1.addAll(l2);
});
```
- Also mit reduzieren, war die Antwort. Ich danke Ihnen sehr.
- Beachten Sie, dass diese Lösung nicht Kurzschluss: werden Sie noch brauchen, zu Durchlaufen die ganze input-stream, und ignorieren alles, was nach dem "STOP". Dies könnte problematisch sein, wenn Sie sehr lange (oder unbegrenzt) stream.
- Gerade realisiert, dass diese Lösung wäre in der Tat sehr langsam, auch für nicht sehr lange Eingaben, wie es kopiert die ganze Liste, bei der jedes neue element verarbeitet. Wenn Sie wie non-short-circuiting-Lösung, ist es besser, zu implementieren Collector statt.
- Ich würde auf jeden Fall nicht sesshaft für eine O(n2) Lösung hier.
- Ich sehe nicht, wie mit ein Sammler würde keinen Unterschied machen, die Sie noch umsetzen müssen, ein Akkumulator und combiner, die im wesentlichen die gleichen zwei Lambda-Ausdrücke übergeben werden, zu verringern.
- ein Sammler führt eine veränderlich Reduzierung, so kann es ändern Sie den vorhandenen Akku. Sie müssen nicht, etwas zu kopieren, markieren Sie die aktuelle Akku und fügen Sie das neue element, wenn nötig. Die linked-list-Lösung im update ist sicherlich overengineered.
- href="https://gist.github.com/amaembo/0bc8e982d179f2e45d7a" >hier sammeln-basierte Lösung. Ich mag es nicht, entweder, wie es ist non-short-circuit, aber es ist zumindest kürzer als deins und O(n). Verwenden Sie für Ihre Antwort, wenn Sie mögen 🙂
- Ich sehe jetzt. Naja zumindest habe ich etwas gelernt.
- versucht, um eine Erklärung und noch eine andere option.
- Hah, hier kommt die peek. Eigentlich ist es nie garantiert, dass findFirst wird, Stoppt der zugrunde liegenden stream processing genau, wenn die Lösung gefunden ist (auch für sequentielle streams). Versuchen Sie ersetzen tokens.stream() mit Stream.of(tokens).flatMap(List::stream). Es ist auch vollkommen legal Strom, der produziert die gleichen Elemente, aber Ihre Lösung funktioniert nicht mit ihm. Stream-API ist hart.
InformationsquelleAutor WillShackleford
13

In JDK9 es wird eine neue Stream Betrieb namens takeWhile, die die Sache ähnlich zu dem, was Sie brauchen. Ich zurück portiert Sie diesen Vorgang, um meine StreamEx Bibliothek, so können Sie es auch in Java-8:
```
List<String> list = StreamEx.of(tokens)
                            .takeWhile(t -> !t.toUpperCase().endsWith("STOP"))
                            .toList();
```
Leider ist es nicht die "STOP" element selbst, so dass der zweite Durchlauf ist notwendig, um es manuell hinzufügen:
```
list.add(StreamEx.of(tokens).findFirst(t -> t.toUpperCase().endsWith("STOP")).get());
```
Beachten Sie, dass beide takeWhile und findFirst sind Kurzschluss-Operationen (Sie wird nicht die gesamte Eingabe-stream, wenn nicht erforderlich), so können Sie verwenden Sie sehr lange oder sogar unendliche streams.

Jedoch mit StreamEx kann man es lösen in single-pass über den trick mit groupRuns. Die groupRuns Methode Gruppen angrenzenden Stream-Elemente, um die List basierend auf dem angegebenen Prädikat, das angibt, ob zwei benachbarte Elemente gruppiert werden sollen oder nicht. Wir sollten in Betracht ziehen, dass die Gruppe endet mit dem element mit "STOP". Dann brauchen wir nur, bis die erste Gruppe:
```
List<String> list = StreamEx.of(tokens)
                            .groupRuns((a, b) -> !a.toUpperCase().endsWith("STOP"))
                            .findFirst().get();
```
Diese Lösung wird auch nicht extra Arbeit, wenn die erste Gruppe fertig ist.
- Dank Tagir. Ihre neueste Lösung mit groupRuns wäre die schönste Art und Weise, dies zu lösen. Schade, daß Sie nicht takeWhile in der stream-API in den ersten Platz. Es ist ein grundlegendes Merkmal der funktionalen Programmierung.
- Stream-API wurde entwickelt, um sowohl eine sequenzielle als auch parallele Verarbeitung, aber takeWhile Betrieb ist sequentieller Natur. Es ist nicht so einfach zu parallelisieren ist es richtig. Wahrscheinlich war das der Grund, warum es nicht enthalten war in JDK 8.
- Es ist möglich zu parallelisieren, aber es potentiell mit einer Vielzahl von Puffern. Wir haben vor allem nicht genügend Zeit, es zu tun in Java 8.
- ja, ich studierte die Umsetzung. Trotzdem bestellte stream Parallelisierung nur selten Verbesserung der Leistung (mit Ausnahme der Fälle, wenn die Bedingung nicht in der Nähe der stream-Ende oder wird immer true). Für ungeordnete parallel stream diese operation ist unwahrscheinlich, nützlich zu sein. Ich kann mir nicht vorstellen jedes Szenario, in dem "eine beliebige Teilmenge" wäre zufriedenstellendes Ergebnis. Nachdem alle, die Sie verwenden können filter die würden auch wieder einige Teilmenge. Mein backport Umsetzung ist ziemlich lahm AbstractSpliterator Unterklasse mit Standard -trySplit: ich habe beschlossen, dass spezielle parallele Handhabung ist Verschwendung von Zeit.
- Ungeordnete takeWhile ist ja meist nutzlos für die konventionelle Sammlung-basierte Probleme, die wir sehen, eine Menge. Es stellt sich heraus, nützlich zu sein, wenn das Prädikat basiert auf externen Zustand, z.B. Verarbeitung von einem Strom von Ereignissen für eine bestimmte Zeit.
- guter Punkt! Ich hätte nie gedacht, über die Verwendung der Stream-API auf diese Weise. Wahrscheinlich wäre es gut, fügen Sie zum Beispiel zu takeWhile JavaDoc...
InformationsquelleAutor Tagir Valeev
10

Wenn Sie wirklich verwenden müssen, Streams API, halten Sie es einfach und verwenden Sie einen Strom von Indizes:
```
int lastIdx = IntStream.range(0, tokens.size())
        .filter(i -> tokens.get(i).toUpperCase().endsWith("STOP"))
        .findFirst()
        .orElse(-1);

List<String> myTokens = tokens.subList(0, lastIdx + 1);
```
Oder eine neue List aus der Unterliste wenn Sie möchten, eine unabhängige Kopie, die nicht unterstützt von der ursprünglichen Liste.
- Eine sehr saubere und schöne Lösung anstatt
InformationsquelleAutor Misha

Mit streng nur Java 8 API:

public static <R> Stream<? extends R> takeUntil(Iterator<R> iterator, Predicate<? super R> stopFilter) {

    return StreamSupport.stream(Spliterators.spliteratorUnknownSize(new Iterator<R>() {
        private R next = null;
        private boolean hasTaken = true;
        private boolean stopIteration = !iterator.hasNext();
        @Override
        public boolean hasNext() {
            if (stopIteration) {
                return false;
            }

            if (!hasTaken) {
                return true;
            }

            if (!iterator.hasNext()) {
                stopIteration = true;
                return false;
            }

            next = iterator.next();
            stopIteration = stopFilter.test(next);
            hasTaken = stopIteration;
            return !stopIteration;
        }

        @Override
        public R next() {
            if (!hasNext()) {
                throw new NoSuchElementException("There are no more items to consume");
            }
            hasTaken = true;
            return next;
        }
    }, 0), false);
}

Können Sie sich dann spezialisieren Sie folgende Möglichkeiten:

Für Gewässer

public static <R> Stream<? extends R> takeUntil(Stream<R> stream, Predicate<? super R> stopFilter) {
    return takeUntil(stream.iterator(), stopFilter);
}

Für Sammlungen

public static <R> Stream<? extends R> takeUntil(Collection<R> col, Predicate<? super R> stopFilter) {
    return takeUntil(col.iterator(), stopFilter);
}

So glücklich, jemand Aktien in die Tiefe Kenntnisse über die Streams API.

InformationsquelleAutor smac89

Obwohl die oben genannten Antworten sind vollkommen gültig, die Sie benötigen, um sammeln und/oder pre-fetch der Elemente vor der Verarbeitung (beides kann ein Problem sein, wenn der Stream sehr lange).

Für meine muss habe ich daher angepasst Louis ' Antwort auf die Frage hingewiesen, von Julian und angepasst, um zu halten der stop/break-Element. Finden Sie die keepBreak parameter ::

public static <T> Spliterator<T> takeWhile(final Spliterator<T> splitr, final Predicate<? super T> predicate, final boolean keepBreak) {
    return new Spliterators.AbstractSpliterator<T>(splitr.estimateSize(), 0) {
        boolean stillGoing = true;

        @Override
        public boolean tryAdvance(final Consumer<? super T> consumer) {
            if (stillGoing) {
                final boolean hadNext = splitr.tryAdvance(elem -> {
                    if (predicate.test(elem)) {
                        consumer.accept(elem);
                    } else {
                        if (keepBreak) {
                            consumer.accept(elem);
                        }
                        stillGoing = false;
                    }
                });
                return hadNext && (stillGoing || keepBreak);
            }
            return false;
        }
    };
}

public static <T> Stream<T> takeWhile(final Stream<T> stream, final Predicate<? super T> predicate, final boolean keepBreak) {
    return StreamSupport.stream(takeWhile(stream.spliterator(), predicate, keepBreak), false);
}

Verwendung:

public List<String> values = Arrays.asList("some", "words", "before", "BREAK", "AFTER");

    @Test
    public void testStopAfter() {
        Stream<String> stream = values.stream();
        //how to filter stream to stop at the first BREAK
        stream = stream.filter(makeUntil(s -> "BREAK".equals(s)));
        final List<String> actual = stream.collect(Collectors.toList());

        final List<String> expected = Arrays.asList("some", "words", "before", "BREAK");
        assertEquals(expected, actual);
    }

Haftungsausschluss: ich bin mir nicht 100% sicher, dass dies funktionieren wird auf parallel (die neue Stream ist sicherlich nicht parallel) oder nicht-sequentielle streams. Bitte kommentieren/Bearbeiten, wenn Sie haben einige Hinweise auf diesem.

Die Frage ist zu Fragen takeUntil nicht takeWhile. Sie sind komplette Gegensätze

InformationsquelleAutor Benoît

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.