Come verificare se un Java 8 Stream è vuoto?

Come posso verificare se a Streamè vuoto e lanciare un'eccezione in caso contrario, come operazione non terminale?

Fondamentalmente, sto cercando qualcosa di equivalente al codice seguente, ma senza materializzare il flusso intermedio. In particolare, il controllo non dovrebbe avvenire prima che il flusso venga effettivamente consumato da un'operazione del terminale.

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

Se riesci a convivere con capacità parallele limitate, la seguente soluzione funzionerà:

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

Ecco un esempio di codice che lo utilizza:

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

Il problema con l'esecuzione parallela (efficiente) è che supportare la suddivisione di Spliteratorrichiede un modo thread-safe per notare se uno dei frammenti ha visto un valore in modo thread-safe. Quindi l'ultimo dei frammenti in esecuzione tryAdvancedeve rendersi conto che è l'ultimo (e nemmeno può avanzare) a lanciare l'eccezione appropriata. Quindi non ho aggiunto il supporto per la divisione qui.

Le altre risposte e commenti sono corretti in quanto per esaminare il contenuto di uno stream, è necessario aggiungere un'operazione da terminale, in tal modo "consumando" lo stream. Tuttavia, è possibile farlo e trasformare il risultato in un flusso, senza eseguire il buffering dell'intero contenuto del flusso. Ecco un paio di esempi:

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

Fondamentalmente trasforma il flusso in un Iteratorper richiamarlo hasNext()e, se vero, trasforma il Iteratorretro in un Stream. Ciò è inefficiente in quanto tutte le operazioni successive sullo stream passeranno attraverso i metodi hasNext()e di Iterator next(), il che implica anche che lo stream viene effettivamente elaborato in modo sequenziale (anche se successivamente viene trasformato in parallelo). Tuttavia, ciò ti consente di testare il flusso senza eseguire il buffering di tutti i suoi elementi.

Probabilmente c'è un modo per farlo usando a Spliteratorinvece di Iterator. Ciò consente potenzialmente al flusso restituito di avere le stesse caratteristiche del flusso di input, inclusa l'esecuzione in parallelo.

Questo può essere sufficiente in molti casi

stream.findAny().isPresent()

È necessario eseguire un'operazione del terminale sullo Stream per applicare uno qualsiasi dei filtri. Quindi non puoi sapere se sarà vuoto finché non lo consumi.

La cosa migliore che puoi fare è terminare lo Stream con un'operazione da findAny()terminale, che si fermerà quando trova un elemento, ma se non ce ne sono, dovrà iterare su tutto l'elenco di input per scoprirlo.

Questo ti aiuterebbe solo se l'elenco di input ha molti elementi e uno dei primi passa i filtri, poiché solo un piccolo sottoinsieme dell'elenco dovrebbe essere consumato prima che tu sappia che lo Stream non è vuoto.

Ovviamente dovrai comunque creare un nuovo Stream per produrre l'elenco di output.

Penso che dovrebbe essere sufficiente per mappare un booleano

Nel codice questo è:

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

Seguendo l'idea di Stuart, questo potrebbe essere fatto con un Spliteratorsimile:

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

Penso che funzioni con Stream paralleli poiché l' stream.spliterator()operazione terminerà il flusso e quindi lo ricostruirà come richiesto

Nel mio caso d'uso avevo bisogno di un valore predefinito Streampiuttosto che di un valore predefinito. è abbastanza facile da cambiare se non è ciò di cui hai bisogno