拾取列表中的元素，直到满足Java8Lambdas的条件

Question

我试图改变我的想法，以功能的方式思考，最近面临着这样一种情况，我需要从列表中提取元素，直到满足一个条件，我找不到一个简单自然的方法来实现这一点。显然我还在学习。

假设我有这个清单：

List<String> tokens = Arrays.asList("pick me", "Pick me", "pick Me",
    "PICK ME", "pick me and STOP", "pick me", "pick me and Stop", "pick me");

// In a non lambdas was you would do it like below
List<String> myTokens = new ArrayList<>();
for (String token : tokens) {
    myTokens.add(token);
    if (token.toUpperCase().endsWith("STOP")) {
        break;
    }
}

提前感谢您的投入

注意：在发布这篇文章之前，我读了用谓词限制流，但是我不知道如何调整这个答案来解决我的问题。任何帮助将不胜感激。

Answer 1

使用严格Java8 API：

public static <R> Stream<? extends R> takeUntil(Iterator<R> iterator, Predicate<? super R> stopFilter) {
    final boolean isParallelStream = false;
    
    return StreamSupport.stream(Spliterators.spliteratorUnknownSize(new Iterator<R>() {
        private R next = null;
        private boolean conditionSatisfied = false;
        private boolean hasTaken = true;
        
        @Override
        public boolean hasNext() {
            if (conditionSatisfied || !iterator.hasNext()) {
                return false;
            }

            if (hasTaken) {
                next = iterator.next();
                conditionSatisfied = stopFilter.test(next);
                hasTaken = false;
            }
            return !conditionSatisfied;
        }

        @Override
        public R next() {
            if (!hasNext()) {
                throw new NoSuchElementException("There are no more items to consume");
            }
            hasTaken = true;
            return next;
        }
    }, 0), isParallelStream);
}

然后可以通过以下方式对其进行专门化：

public static <R> Stream<? extends R> takeUntil(Stream<R> stream, Predicate<? super R> stopFilter) {
    return takeUntil(stream.iterator(), stopFilter);
}

public static <R> Stream<? extends R> takeUntil(Collection<R> col, Predicate<? super R> stopFilter) {
    return takeUntil(col.iterator(), stopFilter);
}

Answer 2

在JDK9中，将有一个名为takeWhile的新Stream操作，它做的事情与您需要的类似。我将此操作向后移植到我的StreamEx库中，因此您甚至可以在Java-8中使用它：

List<String> list = StreamEx.of(tokens)
                            .takeWhile(t -> !t.toUpperCase().endsWith("STOP"))
                            .toList();

不幸的是，它不接受“STOP”元素本身，因此需要第二次手动添加它：

list.add(StreamEx.of(tokens).findFirst(t -> t.toUpperCase().endsWith("STOP")).get());

请注意，两个teking同时和findFirst都是短路操作（如果不必要，它们不会处理整个输入流），因此您可以将它们用于非常长甚至无限的流。

但是，使用StreamEx，您可以使用groupRuns的技巧一次性解决此问题。groupRuns方法根据提供的谓词将相邻的流元素分组到列表，该谓词告诉是否应将两个给定的相邻元素分组。我们可以认为，该组以包含<代码>“停止”< /代码>的元素结束。那么我们只需要看第一组：

List<String> list = StreamEx.of(tokens)
                            .groupRuns((a, b) -> !a.toUpperCase().endsWith("STOP"))
                            .findFirst().get();

当第一组完成时，这个解决方案也不会做额外的工作。

Answer 3

如果确实必须使用Streams API，请保持简单并使用索引流：

int lastIdx = IntStream.range(0, tokens.size())
        .filter(i -> tokens.get(i).toUpperCase().endsWith("STOP"))
        .findFirst()
        .orElse(-1);

List<String> myTokens = tokens.subList(0, lastIdx + 1);

或者，如果您想要不受原始列表支持的独立副本，则从子列表中创建一个新的列表。