¿Cómo comprobar si un flujo de Java 8 está vacío?

¿Cómo puedo comprobar si un Stream está vacío y lanza una excepción si no lo está, como una operación no terminal?

Básicamente, estoy buscando algo equivalente al siguiente código, pero sin materializar el flujo intermedio. En particular, la verificación no debe ocurrir antes de que una operación de terminal consuma realmente el flujo.

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

Esto puede ser suficiente en muchos casos.

stream.findAny().isPresent()

Las otras respuestas y comentarios son correctos en el sentido de que para examinar el contenido de una secuencia, se debe agregar una operación de terminal, “consumiendo” así la secuencia. Sin embargo, uno puede hacer esto y volver a convertir el resultado en una secuencia, sin almacenar en búfer todo el contenido de la secuencia. Aqui hay un par de ejemplos:

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

Básicamente, convierte el flujo en un Iterator para llamar hasNext() en él, y si es cierto, encienda el Iterator volver a un Stream. Esto es ineficiente en el sentido de que todas las operaciones subsiguientes en el flujo pasarán por el iterador. hasNext() y next() métodos, lo que también implica que la secuencia se procesa efectivamente de forma secuencial (incluso si luego se vuelve paralela). Sin embargo, esto le permite probar la secuencia sin almacenar en búfer todos sus elementos.

Probablemente hay una manera de hacer esto usando un Spliterator en lugar de un Iterator. Potencialmente, esto permite que el flujo devuelto tenga las mismas características que el flujo de entrada, incluida la ejecución en paralelo.

Si puede vivir con capacidades paralelas limitadas, la siguiente solución funcionará:

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

Aquí hay un código de ejemplo usándolo:

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

El problema con la ejecución paralela (eficiente) es que admitir la división del Spliterator requiere una forma segura para subprocesos de notar si alguno de los fragmentos ha visto algún valor de una manera segura para subprocesos. Entonces el último de los fragmentos ejecutándose tryAdvance tiene que darse cuenta de que es el último (y tampoco pudo avanzar) para lanzar la excepción apropiada. Así que no agregué soporte para dividir aquí.

Debe realizar una operación de terminal en el Stream para que se aplique cualquiera de los filtros. Por lo tanto, no puedes saber si estará vacío hasta que lo consumas.

Lo mejor que puede hacer es terminar el Stream con un findAny() operación de terminal, que se detendrá cuando encuentre algún elemento, pero si no hay ninguno, tendrá que iterar sobre toda la lista de entrada para encontrarlo.

Esto solo lo ayudaría si la lista de entrada tiene muchos elementos, y uno de los primeros pasa los filtros, ya que solo se tendría que consumir un pequeño subconjunto de la lista antes de saber que Stream no está vacío.

Por supuesto, aún tendrá que crear una nueva secuencia para producir la lista de salida.

Creo que debería ser suficiente para mapear un booleano

En código esto es:

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

Siguiendo la idea de Stuart, esto podría hacerse con un Spliterator como esto:

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

Creo que esto funciona con Streams paralelos como el stream.spliterator() la operación terminará la secuencia y luego la reconstruirá según sea necesario

En mi caso de uso, necesitaba un valor predeterminado Stream en lugar de un valor predeterminado. eso es bastante fácil de cambiar si esto no es lo que necesita

Simplemente usaría:

stream.count()>0