¿Cómo comprobar si una secuencia de Java 8 está vacía?

¿Cómo puedo verificar si a Streamestá vacío y lanzar una excepción si no lo está, como una operación no terminal?

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

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

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 que lo usa:

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 en paralelo (eficiente) es que admitir la división de la Spliteratorrequiere una forma segura de subprocesos para notar si alguno de los fragmentos ha visto algún valor de una manera segura para subprocesos. Luego, el último de los fragmentos en ejecución tryAdvancedebe darse cuenta de que es el último (y tampoco pudo avanzar) en lanzar la excepción apropiada. Entonces no agregué soporte para dividir aquí.

Las otras respuestas y comentarios son correctos en el sentido de que para examinar el contenido de un flujo, se debe agregar una operación de terminal, "consumiendo" así el flujo. Sin embargo, se puede hacer esto y convertir el resultado de nuevo 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, convierta la secuencia en un Iteratorpara invocarla hasNext()y, si es cierto, convierta la parte Iteratorposterior en un Stream. Esto es ineficiente porque todas las operaciones posteriores en la secuencia pasarán por el Iterador hasNext()ynext() métodos , lo que también implica que la secuencia se procesa de manera efectiva de forma secuencial (incluso si luego se convierte en paralelo). Sin embargo, esto le permite probar la transmisión sin almacenar en búfer todos sus elementos.

Probablemente haya una forma de hacer esto usando un en Spliteratorlugar de un Iterator. Esto potencialmente permite que el flujo devuelto tenga las mismas características que el flujo de entrada, incluida la ejecución en paralelo.

Esto puede ser suficiente en muchos casos.

stream.findAny().isPresent()

Debe realizar una operación de terminal en la secuencia para que se aplique cualquiera de los filtros. Por lo tanto, no puede saber si estará vacío hasta que lo consuma.

Lo mejor que puede hacer es finalizar la transmisión con un findAny() operación de terminal, que se detendrá cuando encuentre cualquier elemento, pero si no hay ninguno, tendrá que iterar sobre toda la lista de entrada para averiguarlo.

Esto solo lo ayudaría si la lista de entrada tiene muchos elementos, y uno de los primeros pasa los filtros, ya que solo un pequeño subconjunto de la lista tendría que consumirse 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 algo Spliteratorasí:

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 stream.spliterator()transmisiones paralelas ya que la operación terminará la transmisión y luego la reconstruirá según sea necesario

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