[英]Picking elements of a list until condition is met with Java 8 Lambdas
我试图将我的思想转变为以功能方式思考,最近遇到了一种情况,我需要从列表中提取元素直到满足条件,但我找不到一种简单的自然方法来实现这一点。 显然我还在学习。
说我有这个清单:
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;
}
}
预先感谢您的意见
注意:在发布之前,我阅读了通过谓词限制流,但我不知道如何根据我的问题调整该答案。 任何帮助将不胜感激谢谢。
如果您确实必须使用 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);
或使一个新的List
出来的子表,如果你想,这不是由原始列表支持一个独立的副本。
在 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());
请注意, takeWhile
和findFirst
都是短路操作(如果不需要,它们不会处理整个输入流),因此您可以将它们用于非常长甚至无限的流。
然而,使用StreamEx您可以使用与技巧解决它单程groupRuns
。 groupRuns
方法根据提供的谓词将相邻的 Stream 元素分组到List
,该谓词指示是否应将两个给定的相邻元素分组。 我们可以认为该组以包含"STOP"
的元素结束。 那么我们只需要取第一组:
List<String> list = StreamEx.of(tokens)
.groupRuns((a, b) -> !a.toUpperCase().endsWith("STOP"))
.findFirst().get();
当第一组完成时,此解决方案也不会做额外的工作。
仅使用 Java 8 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);
}
一种选择使用需要两个函数的收集器,一个是将字符串添加到列表中,另一个是组合以前可能并行创建的列表。 对于每个它,仅当前一个部分输出不以以 STOP 结尾的元素结尾时才添加字符串或整个列表:
tokens.stream().collect(() -> new ArrayList<String>(), (l, e) -> {
if(l.isEmpty() || !l.get(l.size()-1).toUpperCase().endsWith("STOP"))
l.add(e);
}, (l1, l2) -> {
if(l1.isEmpty() || !l1.get(l1.size()-1).toUpperCase().endsWith("STOP"))
l1.addAll(l2);
});
尽管上述答案是完全有效的,但它们需要在处理元素之前收集和/或预取元素(如果 Stream 很长,两者都可能是一个问题)。
根据我的需要,我因此改编了路易斯对朱利安指出的问题的回答,并将其改编为保留停止/中断项目。 请参阅keepBreak
参数::
public static <T> Spliterator<T> takeWhile(final Spliterator<T> splitr, final Predicate<? super T> predicate, final boolean keepBreak) {
return new Spliterators.AbstractSpliterator<T>(splitr.estimateSize(), 0) {
boolean stillGoing = true;
@Override
public boolean tryAdvance(final Consumer<? super T> consumer) {
if (stillGoing) {
final boolean hadNext = splitr.tryAdvance(elem -> {
if (predicate.test(elem)) {
consumer.accept(elem);
} else {
if (keepBreak) {
consumer.accept(elem);
}
stillGoing = false;
}
});
return hadNext && (stillGoing || keepBreak);
}
return false;
}
};
}
public static <T> Stream<T> takeWhile(final Stream<T> stream, final Predicate<? super T> predicate, final boolean keepBreak) {
return StreamSupport.stream(takeWhile(stream.spliterator(), predicate, keepBreak), false);
}
用法:
public List<String> values = Arrays.asList("some", "words", "before", "BREAK", "AFTER");
@Test
public void testStopAfter() {
Stream<String> stream = values.stream();
//how to filter stream to stop at the first BREAK
stream = stream.filter(makeUntil(s -> "BREAK".equals(s)));
final List<String> actual = stream.collect(Collectors.toList());
final List<String> expected = Arrays.asList("some", "words", "before", "BREAK");
assertEquals(expected, actual);
}
免责声明:我不是 100% 确定这将适用于并行(新的 Stream 肯定不是并行的)或非顺序流。 如果您对此有一些提示,请发表评论/编辑。
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.