如果没有元素，则流的特殊行为

Question

我如何用java8流式API表达这一点？

我想对流中的每个项执行itemcumer。如果没有要执行的项目，则清空操作。

我当然可以写这样的东西：

Consumer<Object> itemConsumer = System.out::println;
Runnable emptyAction = () -> {System.out.println("no elements");};

Stream<Object> stream = Stream.of("a","b"); // or Stream.empty()
List<Object> list = stream.collect(Collectors.toList());
if (list.isEmpty())
    emptyAction.run();
else
    list.stream().forEach(itemConsumer);

但我更愿意避免任何Lists。

我还考虑过在peek方法中设置一个标志，但该标志是非最终的，因此是不允许的。使用布尔容器似乎也是一种太多的变通方法。

Answer 1

有一个简单直接的解决方案：

Spliterator<Object> sp=stream.spliterator();
if(!sp.tryAdvance(itemConsumer))
    emptyAction.run();
else
    sp.forEachRemaining(itemConsumer);

如果您愿意，您甚至可以保留对第一个元素之后的元素的并行支持：

Spliterator<Object> sp=stream.parallel().spliterator();
if(!sp.tryAdvance(itemConsumer))
    emptyAction.run();
else
    StreamSupport.stream(sp, true).forEach(itemConsumer);

在我看来，作为一种基于reduce的解决方案更容易理解。

Answer 2

没有任何附加变量的解决方案：

stream.peek(itemConsumer).reduce((a, b) -> a).orElseGet(() -> {
    emptyAction.run();
    return null;
});

注意，如果流是并行的，那么可以为不同线程中的不同元素同时调用itemcumer（例如在forEach中，而不是在forEachOrdered中）。此外，如果第一个流元素为null，该解决方案将失败。

Answer 3

您可以强制reduce来执行此操作。逻辑是在遇到任何有用数据时，将值设置为“真”。

然后，reduce的结果为false，则未遇到任何项目。如果遇到任何项目，则结果将为true：

boolean hasItems = stream.reduce(false, (o, i) -> {
    itemConsumer.accept(i);
    return true;
}, (l, r) -> l | r);
if (!hasItems) {
    emptyAction.run();
}

这对于并行流应该很有效，因为任何遇到项目的流都会将值设置为true。

然而，我不确定我是否喜欢这个，因为这是一个稍微迟钝的减少操作。

另一种方法是使用原子布尔作为可变的布尔容器：

final AtomicBoolean hasItems = new AtomicBoolean(false);
stream.forEach(i -> {
    itemConsumer.accept(i);
    hasItems.set(true);
});
if (!hasItems.get()) {
    emptyAction.run();
}

然而，我不知道我是否或多或少喜欢这个。

最后，您可以让您的项目消费者记住状态：

class ItemConsumer implements Consumer<Object> {

    private volatile boolean hasConsumedAny;

    @Override
    public void accept(Object o) {
        hasConsumedAny = true;
        //magic magic
    }

    public boolean isHasConsumedAny() {
        return hasConsumedAny;
    }
}

final ItemConsumer itemConsumer = new ItemConsumer();
stream.forEach(itemConsumer::accept);
if (!itemConsumer.isHasConsumedAny()) {
    emptyAction.run();
}

这看起来有点整洁，但可能不实用。也许是一个装饰图案-

class ItemConsumer<T> implements Consumer<T> {

    private volatile boolean hasConsumedAny;
    private final Consumer<T> delegate;

    ItemConsumer(final Consumer<T> delegate) {
        this.delegate = delegate;
    }

    @Override
    public void accept(T t) {
        hasConsumedAny = true;
        delegate.accept(t);
    }

    public boolean isHasConsumedAny() {
        return hasConsumedAny;
    }
}

final ItemConsumer<Object> consumer = new ItemConsumer<Object>(() -> /** magic **/);

太长别读：有些东西必须记住您在使用Stream期间是否遇到了什么，可以是：

• Stream本身在duce的情况下；
• 原子布尔；或
• 消费者

我认为从逻辑的角度来看，消费者可能处于最佳位置。