Como verificar se um Java 8 Stream está vazio?

Como posso verificar se a Streamestá vazio e lançar uma exceção se não estiver, como uma operação não terminal?

Basicamente, estou procurando algo equivalente ao código abaixo, mas sem materializar o fluxo intermediário. Em particular, a verificação não deve ocorrer antes que o fluxo seja realmente consumido por uma operação 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();
}

Se você pode viver com capacidades paralelas limitadas, a seguinte solução 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);
}

Aqui está um exemplo de código usando-o:

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

O problema com a execução paralela (eficiente) é que o suporte à divisão do Spliteratorrequer uma maneira segura de thread para perceber se algum dos fragmentos viu algum valor de maneira segura. Então, o último dos fragmentos em execução tryAdvanceprecisa perceber que é o último (e também não pode avançar) a lançar a exceção apropriada. Portanto, não adicionei suporte para divisão aqui.

As outras respostas e comentários estão corretos no sentido de que para examinar o conteúdo de um fluxo, é necessário adicionar uma operação de terminal, "consumindo" assim o fluxo. No entanto, pode-se fazer isso e transformar o resultado de volta em um fluxo, sem armazenar todo o conteúdo do fluxo. Aqui estão alguns exemplos:

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

Basicamente, transforme o stream em um Iteratorpara chamá hasNext()-lo e, se verdadeiro, transforme as Iteratorcostas em um Stream. Isso é ineficiente porque todas as operações subsequentes no fluxo passarão pelos métodos hasNext()e do Agente Iterativo next(), o que também implica que o fluxo é efetivamente processado sequencialmente (mesmo se posteriormente for tornado paralelo). No entanto, isso permite que você teste o fluxo sem armazenar em buffer todos os seus elementos.

Provavelmente existe uma maneira de fazer isso usando um em Spliteratorvez de um Iterator. Isso permite que o fluxo retornado tenha as mesmas características do fluxo de entrada, incluindo a execução em paralelo.

Isso pode ser suficiente em muitos casos

stream.findAny().isPresent()

Você deve realizar uma operação de terminal no Stream para que qualquer um dos filtros seja aplicado. Portanto, você não pode saber se ele estará vazio até que você o consuma.

O melhor que você pode fazer é encerrar o Stream com uma findAny()operação de terminal, que irá parar quando encontrar qualquer elemento, mas se não houver nenhum, terá que iterar em toda a lista de entrada para descobrir isso.

Isso só ajudaria se a lista de entrada tivesse muitos elementos e um dos primeiros passasse pelos filtros, já que apenas um pequeno subconjunto da lista teria que ser consumido antes de você saber que o Fluxo não está vazio.

Claro, você ainda terá que criar um novo fluxo para produzir a lista de saída.

Eu acho que deve ser o suficiente para mapear um booleano

No código é:

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

Seguindo a ideia de Stuart, isso poderia ser feito da Spliteratorseguinte forma:

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

Acho que isso funciona com fluxos paralelos, pois a stream.spliterator()operação encerrará o fluxo e, em seguida, o reconstruirá conforme necessário

Em meu caso de uso, eu precisava de um valor padrão em Streamvez de um valor padrão. isso é muito fácil de mudar se não for o que você precisa