如何检查Java 8流是否为空？

Question

如何检查Stream是否为空，如果不是，则抛出异常，作为非终端操作？

基本上，我正在寻找与下面代码等效的东西，但没有实现中间的流。特别是，在流被终端操作实际使用之前，不应该进行检查。

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

Answer 1

如果您可以在有限的并行能力下生活，那么以下解决方案将起作用：

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

下面是一些使用它的示例代码：

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

（高效）并行执行的问题在于，支持拆分Spliterator需要一种线程安全的方式来注意其中任何一个片段是否以线程安全的方式看到了任何值。然后执行tryAdvance的最后一个片段必须意识到它是抛出适当异常的最后一个片段（而且它也不能前进）。所以我没有在这里添加对拆分的支持。

Answer 2

其他答案和注释是正确的，因为要检查流的内容，必须添加终端操作，从而“消费”流。但是，可以这样做，并将结果返回到流中，而无需缓冲流的全部内容。以下是几个示例：

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

基本上将流转换为Iterator以便在其上调用hasNext（），如果为true，则将Iterator转换回Stream。这是低效的，因为对流的所有后续操作都将通过Iterator的hasNext（）和Next（）方法，这也意味着流被有效地按顺序处理（即使它后来被转换为并行）。然而，这确实允许您在不缓冲其所有元素的情况下测试流。

可能有一种方法可以使用拆分器（Spliterator）而不是迭代器（Iterator）。这可能允许返回的流具有与输入流相同的特性，包括并行运行。

Answer 3

在许多情况下这可能就足够了

stream.findAny().isPresent()