如何匹配流元素但如果不存在则返回false？

Question

我有一个流，想检查是否都匹配过滤器。如果都匹配，则返回true。

但是，如果流是空的，我想返回false。

我该怎么做？

示例代码：

public boolean validate(Stream<Whatever> stream) {
  // Problem: returns **true** if stream empty.
  // How can **false** be returned if stream is empty?
  return stream.allMatch(Whatever::someCheck);
}

Answer 1

你可以使用

public boolean validate(Stream<Whatever> stream) {
    return stream.map(Whatever::someCheck).reduce(Boolean::logicalAnd).orElse(false);
}

表达意图。我们将每个元素映射到一个 boolean 值，表示它是否匹配，并使用逻辑 and 操作来减少所有元素，如果它们都是true，则将产生true。如果没有元素，reduce 将返回一个空的Optional，我们使用orElse(false) 将其映射到false，正如预期的那样。

唯一的缺点是这是非短路的，即不会立即在第一个不匹配的元素处停止。

仍然支持短路的解决方案可能会更加完善：

public boolean validate(Stream<Whatever> stream) {
    boolean parallel = stream.isParallel();
    Spliterator<Whatever> sp = stream.spliterator();
    if(sp.getExactSizeIfKnown() == 0) return false;
    Stream.Builder<Whatever> b = Stream.builder();
    if(!sp.tryAdvance(b)) return false;
    return Stream.concat(b.build(), StreamSupport.stream(sp, parallel))
        .allMatch(Whatever::someCheck);
}

这是Eugene’s answer 的变体，但它不会丢失特性或并行性，并且总体上可能更高效。

Answer 2

下面的代码可以工作（我测试过）。

public static boolean validate(Stream<Whatever> stream) {
    return stream.reduce((whatever1, whatever2) -> Whatever.someCheck(whatever1) ? whatever2 : whatever1)
            .map(Whatever::someCheck).orElse(false);
}

它是如何工作的？我们使用reduce 操作来检查每个元素是否与谓词匹配，如果失败，我们会继续返回失败的元素（在三元操作中）。最后，我们将缩减后的Whatever 对象映射为布尔值，如果为真：则全部匹配且不为空（orElse(false)）。

Answer 3

如果您对失去自己的特征和并行性感到满意，例如：

 public static boolean validate(Stream<String> stream) {
    Iterator<String> it = stream.iterator();

    if (!it.hasNext()) {
        return false;
    }

    return StreamSupport.stream(Spliterators.spliteratorUnknownSize(it, 0), false)
            .peek(System.out::println)
            .allMatch(x -> x.contains("a"));

}

Answer 4

试试peek

boolean[] flag = new boolean[1];
return stream.peek(t -> flag[0] = true).allMatch(Whatever::someCheck) && flag[0]

Answer 5

我已经添加了两个我现在删除的答案，但问题一直困扰着我，所以我第三次尝试，这次它可以工作，包括保留allMatch。这是方法validate的代码。

public static boolean validate(Stream<Whatever> stream) {
    final boolean[] streamNotEmpty = new boolean[1];
    return stream.filter(elem -> {
        streamNotEmpty[0] = true;
        return true;
    }).allMatch(Whatever::someCheck) && streamNotEmpty[0];
}

更短的版本是

public static boolean validate(Stream<Whatever> stream) {
    final boolean[] streamNotEmpty = new boolean[1];
    return stream.allMatch(elem -> {
        streamNotEmpty[0] = true;
        return elem.someCheck();
    }) && streamNotEmpty[0];
}

这背后的想法是我们想知道流中是否至少有一个元素，所以我创建了一个final boolean[]，它的值在过滤器调用中发生了变化。因此，在流处理结束时，我们可以检查流是否为空，并在返回结果时采取相应措施。

这是一个完整的课程，包括测试用例来证明 - 这一次终于 - 我提供了一个有效的解决方案。

import java.util.ArrayList;
import java.util.stream.Stream;

public class StreamTest {

    public static boolean validate(Stream<Whatever> stream) {
        final boolean[] streamNotEmpty = new boolean[1];
        return stream.allMatch(elem -> {
            streamNotEmpty[0] = true;
            return elem.someCheck();
        }) && streamNotEmpty[0];
    }

    static class Whatever {
        private boolean checkResult;

        public Whatever() {
            this(false);
        }

        public Whatever(boolean b) {
            this.checkResult = b;
        }

        public boolean someCheck() {
            return checkResult;
        }
    }

    public final static void main(String[] args) {
        ArrayList<Whatever> list = new ArrayList<>();
        System.out.println("empty list: " + validate(list.stream()));
        System.out.println("empty list parallel: " + validate(list.parallelStream()));

        for (int i = 0; i < 10000; i++) {
            list.add(new Whatever(true));
        }

        System.out.println("non empty true list: " + validate(list.stream()));
        System.out.println("non empty true list parallel: " + validate(list.parallelStream()));

        for (int i = 0; i < 10000; i += 1000) {
            list.add(new Whatever(false));
        }

        System.out.println("non empty false list: " + validate(list.stream()));
        System.out.println("non empty false list parallel: " + validate(list.parallelStream()));
    }
}

执行时的输出是：

empty list: false empty list parallel: false non empty true list: true non empty true list parallel: true non empty false list: false non empty false list parallel: false

Answer 6

return !stream.filter(Whatever::someCheck).collect(Collectors.toList()).isEmpty()