Wie überprüfe ich, ob ein Java 8-Stream leer ist?

Wie kann ich überprüfen, ob a Streamleer ist, und eine Ausnahme auslösen, wenn dies nicht der Fall ist, als nicht-terminale Operation?

Grundsätzlich suche ich nach etwas, das dem folgenden Code entspricht, ohne jedoch den dazwischen liegenden Stream zu materialisieren. Insbesondere sollte die Überprüfung nicht erfolgen, bevor der Stream tatsächlich von einer Terminaloperation verbraucht wird.

public Stream<Thing> getFilteredThings() {
    Stream<Thing> stream = getThings().stream()
                .filter(Thing::isFoo)
                .filter(Thing::isBar);
    return nonEmptyStream(stream, () -> {
        throw new RuntimeException("No foo bar things available")   
    });
}

private static <T> Stream<T> nonEmptyStream(Stream<T> stream, Supplier<T> defaultValue) {
    List<T> list = stream.collect(Collectors.toList());
    if (list.isEmpty()) list.add(defaultValue.get());
    return list.stream();
}

Wenn Sie mit eingeschränkten parallelen Funktionen leben können, funktioniert die folgende Lösung:

private static <T> Stream<T> nonEmptyStream(
    Stream<T> stream, Supplier<RuntimeException> e) {

    Spliterator<T> it=stream.spliterator();
    return StreamSupport.stream(new Spliterator<T>() {
        boolean seen;
        public boolean tryAdvance(Consumer<? super T> action) {
            boolean r=it.tryAdvance(action);
            if(!seen && !r) throw e.get();
            seen=true;
            return r;
        }
        public Spliterator<T> trySplit() { return null; }
        public long estimateSize() { return it.estimateSize(); }
        public int characteristics() { return it.characteristics(); }
    }, false);
}

Hier ist ein Beispielcode, der ihn verwendet:

List<String> l=Arrays.asList("hello", "world");
nonEmptyStream(l.stream(), ()->new RuntimeException("No strings available"))
  .forEach(System.out::println);
nonEmptyStream(l.stream().filter(s->s.startsWith("x")),
               ()->new RuntimeException("No strings available"))
  .forEach(System.out::println);

Das Problem bei der (effizienten) parallelen Ausführung besteht darin, dass für die Unterstützung der Aufteilung des SpliteratorThreads eine threadsichere Methode erforderlich ist, um festzustellen, ob eines der Fragmente einen threadsicheren Wert aufweist. Dann muss das letzte der ausgeführten Fragmente tryAdvanceerkennen, dass es das letzte ist (und es konnte auch nicht vorrücken), das die entsprechende Ausnahme auslöst. Daher habe ich hier keine Unterstützung für die Aufteilung hinzugefügt.

Die anderen Antworten und Kommentare sind insofern richtig, als man zum Untersuchen des Inhalts eines Streams eine Terminaloperation hinzufügen muss, wodurch der Stream "verbraucht" wird. Sie können dies jedoch tun und das Ergebnis wieder in einen Stream umwandeln, ohne den gesamten Inhalt des Streams zu puffern. Hier einige Beispiele:

static <T> Stream<T> throwIfEmpty(Stream<T> stream) {
    Iterator<T> iterator = stream.iterator();
    if (iterator.hasNext()) {
        return StreamSupport.stream(Spliterators.spliteratorUnknownSize(iterator, 0), false);
    } else {
        throw new NoSuchElementException("empty stream");
    }
}

static <T> Stream<T> defaultIfEmpty(Stream<T> stream, Supplier<T> supplier) {
    Iterator<T> iterator = stream.iterator();
    if (iterator.hasNext()) {
        return StreamSupport.stream(Spliterators.spliteratorUnknownSize(iterator, 0), false);
    } else {
        return Stream.of(supplier.get());
    }
}

Verwandeln Sie den Stream in einen Iterator, um ihn aufzurufen hasNext(), und wenn dies zutrifft, verwandeln Sie den IteratorRücken in einen Stream. Dies ist insofern ineffizient, als alle nachfolgenden Operationen auf dem Stream die Iteratoren hasNext()und next()Methoden durchlaufen , was auch impliziert, dass der Stream effektiv sequentiell verarbeitet wird (selbst wenn er später parallel gedreht wird). Auf diese Weise können Sie den Stream jedoch testen, ohne alle Elemente zu puffern.

Es gibt wahrscheinlich eine Möglichkeit, dies mit a Spliteratoranstelle von a zu tun Iterator. Dies ermöglicht möglicherweise, dass der zurückgegebene Stream dieselben Eigenschaften wie der Eingabestream aufweist, einschließlich der parallelen Ausführung.

Sie müssen eine Terminaloperation für den Stream ausführen, damit einer der Filter angewendet wird. Daher können Sie nicht wissen, ob es leer sein wird, bis Sie es verbrauchen.

Das Beste, was Sie tun können, ist, den Stream mit einer findAny()Terminaloperation zu beenden , die beendet wird, wenn ein Element gefunden wird. Wenn jedoch keines vorhanden ist, muss die gesamte Eingabeliste durchlaufen werden, um dies herauszufinden.

Dies würde Ihnen nur helfen, wenn die Eingabeliste viele Elemente enthält und einer der ersten die Filter durchläuft, da nur eine kleine Teilmenge der Liste verbraucht werden müsste, bevor Sie wissen, dass der Stream nicht leer ist.

Natürlich müssen Sie noch einen neuen Stream erstellen, um die Ausgabeliste zu erstellen.

Dies kann in vielen Fällen ausreichend sein

stream.findAny().isPresent()

Ich denke, sollte ausreichen, um einen Booleschen Wert abzubilden

Im Code ist dies:

boolean isEmpty = anyCollection.stream()
    .filter(p -> someFilter(p)) // Add my filter
    .map(p -> Boolean.TRUE) // For each element after filter, map to a TRUE
    .findAny() // Get any TRUE
    .orElse(Boolean.FALSE); // If there is no match return false

Nach Stuarts Idee könnte dies folgendermaßen geschehen Spliterator:

static <T> Stream<T> defaultIfEmpty(Stream<T> stream, Stream<T> defaultStream) {
    final Spliterator<T> spliterator = stream.spliterator();
    final AtomicReference<T> reference = new AtomicReference<>();
    if (spliterator.tryAdvance(reference::set)) {
        return Stream.concat(Stream.of(reference.get()), StreamSupport.stream(spliterator, stream.isParallel()));
    } else {
        return defaultStream;
    }
}

Ich denke, dies funktioniert mit parallelen Streams, da der stream.spliterator()Vorgang den Stream beendet und ihn dann nach Bedarf neu erstellt

In meinem Anwendungsfall benötigte ich einen Standardwert Streamanstelle eines Standardwerts. Das ist ziemlich einfach zu ändern, wenn dies nicht das ist, was Sie brauchen