是否有 Java 8 流操作限制（可能无限）Stream直到第一个元素无法匹配谓词？
在 Java 9 中，我们可以使用takeWhile下面的示例打印所有小于 10 的数字。
IntStream
.iterate(1, n -> n + 1)
.takeWhile(n -> n < 10)
.forEach(System.out::println);
由于 Java 8 中没有这样的操作，以一般方式实现它的最佳方法是什么？
问问题
83467 次
19 回答
162
操作takeWhile并dropWhile已添加到 JDK 9。您的示例代码
IntStream
.iterate(1, n -> n + 1)
.takeWhile(n -> n < 10)
.forEach(System.out::println);
在 JDK 9 下编译和运行时，其行为将完全符合您的预期。
JDK 9 已经发布。可在此处下载：JDK 9 Releases。
于 2015-08-31T05:36:53.713 回答
84
这样的操作在 Java 8中应该是可能Stream的，但它不一定能有效地完成——例如，你不一定能并行化这样的操作，因为你必须按顺序查看元素。
API 没有提供一种简单的方法来做到这一点，但最简单的方法可能是 take Stream.iterator()，包装Iterator以具有“take-while”实现，然后返回 aSpliterator然后 a Stream。或者——也许——包装Spliterator，尽管在这个实现中它不能再被分割了。
takeWhile这是on a的未经测试的实现Spliterator：
static <T> Spliterator<T> takeWhile(
Spliterator<T> splitr, Predicate<? super T> predicate) {
return new Spliterators.AbstractSpliterator<T>(splitr.estimateSize(), 0) {
boolean stillGoing = true;
@Override public boolean tryAdvance(Consumer<? super T> consumer) {
if (stillGoing) {
boolean hadNext = splitr.tryAdvance(elem -> {
if (predicate.test(elem)) {
consumer.accept(elem);
} else {
stillGoing = false;
}
});
return hadNext && stillGoing;
}
return false;
}
};
}
static <T> Stream<T> takeWhile(Stream<T> stream, Predicate<? super T> predicate) {
return StreamSupport.stream(takeWhile(stream.spliterator(), predicate), false);
}
于 2013-12-24T19:09:13.387 回答
57
allMatch()是一个短路功能，因此您可以使用它来停止处理。主要缺点是您必须进行两次测试：一次是看是否应该处理它，另一次是看是否继续进行。
IntStream
.iterate(1, n -> n + 1)
.peek(n->{if (n<10) System.out.println(n);})
.allMatch(n->n < 10);
于 2014-11-13T22:28:51.327 回答
37
作为@StuartMarks answer的后续行动。我的StreamEx库具有takeWhile与当前 JDK-9 实现兼容的操作。在 JDK-9 下运行时，它只会委托给 JDK 实现（通过MethodHandle.invokeExact它非常快）。在 JDK-8 下运行时，将使用“polyfill”实现。所以使用我的库可以像这样解决问题：
IntStreamEx.iterate(1, n -> n + 1)
.takeWhile(n -> n < 10)
.forEach(System.out::println);
于 2015-08-31T06:16:47.647 回答
14
takeWhile是protonpack 库提供的功能之一。
Stream<Integer> infiniteInts = Stream.iterate(0, i -> i + 1);
Stream<Integer> finiteInts = StreamUtils.takeWhile(infiniteInts, i -> i < 10);
assertThat(finiteInts.collect(Collectors.toList()),
hasSize(10));
于 2014-09-04T14:55:01.753 回答
11
更新：Java 9Stream现在带有一个takeWhile方法。
不需要黑客或其他解决方案。就用那个！
我相信这可以大大改进：（也许有人可以使它成为线程安全的）
Stream<Integer> stream = Stream.iterate(0, n -> n + 1);
TakeWhile.stream(stream, n -> n < 10000)
.forEach(n -> System.out.print((n == 0 ? "" + n : "," + n)));
一个黑客肯定......不优雅 - 但它有效〜：D
class TakeWhile<T> implements Iterator<T> {
private final Iterator<T> iterator;
private final Predicate<T> predicate;
private volatile T next;
private volatile boolean keepGoing = true;
public TakeWhile(Stream<T> s, Predicate<T> p) {
this.iterator = s.iterator();
this.predicate = p;
}
@Override
public boolean hasNext() {
if (!keepGoing) {
return false;
}
if (next != null) {
return true;
}
if (iterator.hasNext()) {
next = iterator.next();
keepGoing = predicate.test(next);
if (!keepGoing) {
next = null;
}
}
return next != null;
}
@Override
public T next() {
if (next == null) {
if (!hasNext()) {
throw new NoSuchElementException("Sorry. Nothing for you.");
}
}
T temp = next;
next = null;
return temp;
}
public static <T> Stream<T> stream(Stream<T> s, Predicate<T> p) {
TakeWhile tw = new TakeWhile(s, p);
Spliterator split = Spliterators.spliterator(tw, Integer.MAX_VALUE, Spliterator.ORDERED);
return StreamSupport.stream(split, false);
}
}
于 2013-12-25T11:30:18.650 回答
8
您可以使用 java8 + rxjava。
import java.util.stream.IntStream;
import rx.Observable;
// Example 1)
IntStream intStream = IntStream.iterate(1, n -> n + 1);
Observable.from(() -> intStream.iterator())
.takeWhile(n ->
{
System.out.println(n);
return n < 10;
}
).subscribe() ;
// Example 2
IntStream intStream = IntStream.iterate(1, n -> n + 1);
Observable.from(() -> intStream.iterator())
.takeWhile(n -> n < 10)
.forEach( n -> System.out.println(n));
于 2015-06-02T15:49:11.640 回答
7
实际上，在 Java 8 中有两种方法可以做到这一点，无需任何额外的库或使用 Java 9。
如果你想在控制台上打印 2 到 20 的数字，你可以这样做：
IntStream.iterate(2, (i) -> i + 2).peek(System.out::println).allMatch(i -> i < 20);
或者
IntStream.iterate(2, (i) -> i + 2).peek(System.out::println).anyMatch(i -> i >= 20);
输出在这两种情况下：
2
4
6
8
10
12
14
16
18
20
还没有人提到anyMatch。这就是这个帖子的原因。
于 2017-05-04T10:05:32.677 回答
6
这是从 JDK 9 java.util.stream.Stream.takeWhile(Predicate) 复制的源代码。为了与 JDK 8 一起工作，有一点不同。
static <T> Stream<T> takeWhile(Stream<T> stream, Predicate<? super T> p) {
class Taking extends Spliterators.AbstractSpliterator<T> implements Consumer<T> {
private static final int CANCEL_CHECK_COUNT = 63;
private final Spliterator<T> s;
private int count;
private T t;
private final AtomicBoolean cancel = new AtomicBoolean();
private boolean takeOrDrop = true;
Taking(Spliterator<T> s) {
super(s.estimateSize(), s.characteristics() & ~(Spliterator.SIZED | Spliterator.SUBSIZED));
this.s = s;
}
@Override
public boolean tryAdvance(Consumer<? super T> action) {
boolean test = true;
if (takeOrDrop && // If can take
(count != 0 || !cancel.get()) && // and if not cancelled
s.tryAdvance(this) && // and if advanced one element
(test = p.test(t))) { // and test on element passes
action.accept(t); // then accept element
return true;
} else {
// Taking is finished
takeOrDrop = false;
// Cancel all further traversal and splitting operations
// only if test of element failed (short-circuited)
if (!test)
cancel.set(true);
return false;
}
}
@Override
public Comparator<? super T> getComparator() {
return s.getComparator();
}
@Override
public void accept(T t) {
count = (count + 1) & CANCEL_CHECK_COUNT;
this.t = t;
}
@Override
public Spliterator<T> trySplit() {
return null;
}
}
return StreamSupport.stream(new Taking(stream.spliterator()), stream.isParallel()).onClose(stream::close);
}
于 2017-09-27T11:17:02.403 回答
4
这是一个在整数上完成的版本 - 如问题中所述。
用法：
StreamUtil.takeWhile(IntStream.iterate(1, n -> n + 1), n -> n < 10);
这是 StreamUtil 的代码：
import java.util.PrimitiveIterator;
import java.util.Spliterators;
import java.util.function.IntConsumer;
import java.util.function.IntPredicate;
import java.util.stream.IntStream;
import java.util.stream.StreamSupport;
public class StreamUtil
{
public static IntStream takeWhile(IntStream stream, IntPredicate predicate)
{
return StreamSupport.intStream(new PredicateIntSpliterator(stream, predicate), false);
}
private static class PredicateIntSpliterator extends Spliterators.AbstractIntSpliterator
{
private final PrimitiveIterator.OfInt iterator;
private final IntPredicate predicate;
public PredicateIntSpliterator(IntStream stream, IntPredicate predicate)
{
super(Long.MAX_VALUE, IMMUTABLE);
this.iterator = stream.iterator();
this.predicate = predicate;
}
@Override
public boolean tryAdvance(IntConsumer action)
{
if (iterator.hasNext()) {
int value = iterator.nextInt();
if (predicate.test(value)) {
action.accept(value);
return true;
}
}
return false;
}
}
}
于 2014-07-02T12:43:18.487 回答
2
去获取图书馆AbacusUtil。它提供了您想要的确切 API 以及更多：
IntStream.iterate(1, n -> n + 1).takeWhile(n -> n < 10).forEach(System.out::println);
声明：我是AbacusUtil的开发者。
于 2016-11-30T19:28:46.437 回答
1
如果您知道将要执行的确切重复次数，您可以执行
IntStream
.iterate(1, n -> n + 1)
.limit(10)
.forEach(System.out::println);
于 2018-09-24T03:10:57.483 回答
1
IntStream.iterate(1, n -> n + 1)
.peek(System.out::println) //it will be executed 9 times
.filter(n->n>=9)
.findAny();
而不是峰值，您可以使用 mapToObj 返回最终对象或消息
IntStream.iterate(1, n -> n + 1)
.mapToObj(n->{ //it will be executed 9 times
if(n<9)
return "";
return "Loop repeats " + n + " times";});
.filter(message->!message.isEmpty())
.findAny()
.ifPresent(System.out::println);
于 2019-04-23T13:21:41.227 回答
0
除非通过短路终端操作，否则您不能中止流，这将使某些流值未处理，而不管它们的值如何。但是，如果您只想避免对流进行操作，则可以向流中添加转换和过滤器：
import java.util.Objects;
class ThingProcessor
{
static Thing returnNullOnCondition(Thing thing)
{ return( (*** is condition met ***)? null : thing); }
void processThings(Collection<Thing> thingsCollection)
{
thingsCollection.stream()
*** regular stream processing ***
.map(ThingProcessor::returnNullOnCondition)
.filter(Objects::nonNull)
*** continue stream processing ***
}
} // class ThingProcessor
当事物满足某些条件时，它将事物流转换为空值，然后过滤掉空值。如果您愿意沉迷于副作用，您可以在遇到某些事情时将条件值设置为 true，这样所有后续的事情都会被过滤掉，而不管它们的值如何。但即使不是，您也可以通过从流中过滤掉您不想处理的值来节省大量（如果不是全部）处理。
于 2017-03-09T22:39:58.920 回答
0
即使我也有类似的要求——调用网络服务，如果失败，重试 3 次。如果经过多次试验仍失败，请发送电子邮件通知。在谷歌上搜索了很多之后，anyMatch()作为救世主来了。我的示例代码如下。在下面的示例中，如果webServiceCall方法在第一次迭代本身中返回 true，则 stream 不会像我们调用的那样进一步迭代anyMatch()。我相信，这就是你要找的。
import java.util.stream.IntStream;
import io.netty.util.internal.ThreadLocalRandom;
class TrialStreamMatch {
public static void main(String[] args) {
if(!IntStream.range(1,3).anyMatch(integ -> webServiceCall(integ))){
//Code for sending email notifications
}
}
public static boolean webServiceCall(int i){
//For time being, I have written a code for generating boolean randomly
//This whole piece needs to be replaced by actual web-service client code
boolean bool = ThreadLocalRandom.current().nextBoolean();
System.out.println("Iteration index :: "+i+" bool :: "+bool);
//Return success status -- true or false
return bool;
}
于 2017-10-24T13:02:23.943 回答
-2
如果您有不同的问题，可能需要不同的解决方案，但对于您当前的问题，我会简单地选择：
IntStream
.iterate(1, n -> n + 1)
.limit(10)
.forEach(System.out::println);
于 2017-06-15T14:53:46.850 回答
-2
可能有点跑题了，但这是我们所拥有的，List<T>而不是Stream<T>.
首先你需要有一个takeutil 方法。此方法采用第一个n元素：
static <T> List<T> take(List<T> l, int n) {
if (n <= 0) {
return newArrayList();
} else {
int takeTo = Math.min(Math.max(n, 0), l.size());
return l.subList(0, takeTo);
}
}
它就像scala.List.take
assertEquals(newArrayList(1, 2, 3), take(newArrayList(1, 2, 3, 4, 5), 3));
assertEquals(newArrayList(1, 2, 3), take(newArrayList(1, 2, 3), 5));
assertEquals(newArrayList(), take(newArrayList(1, 2, 3), -1));
assertEquals(newArrayList(), take(newArrayList(1, 2, 3), 0));
现在编写一个takeWhile基于take
static <T> List<T> takeWhile(List<T> l, Predicate<T> p) {
return l.stream().
filter(p.negate()).findFirst(). // find first element when p is false
map(l::indexOf). // find the index of that element
map(i -> take(l, i)). // take up to the index
orElse(l); // return full list if p is true for all elements
}
它是这样工作的：
assertEquals(newArrayList(1, 2, 3), takeWhile(newArrayList(1, 2, 3, 4, 3, 2, 1), i -> i < 4));
此实现部分迭代列表几次，但不会添加添加O(n^2)操作。希望这是可以接受的。
于 2018-07-19T13:10:38.033 回答
-3
我通过实现这个有另一个快速的解决方案（这实际上是不干净的，但你明白了）：
public static void main(String[] args) {
System.out.println(StreamUtil.iterate(1, o -> o + 1).terminateOn(15)
.map(o -> o.toString()).collect(Collectors.joining(", ")));
}
static interface TerminatedStream<T> {
Stream<T> terminateOn(T e);
}
static class StreamUtil {
static <T> TerminatedStream<T> iterate(T seed, UnaryOperator<T> op) {
return new TerminatedStream<T>() {
public Stream<T> terminateOn(T e) {
Builder<T> builder = Stream.<T> builder().add(seed);
T current = seed;
while (!current.equals(e)) {
current = op.apply(current);
builder.add(current);
}
return builder.build();
}
};
}
}
于 2014-10-08T10:53:04.437 回答
-3
这是我仅使用 Java Stream 库的尝试。
IntStream.iterate(0, i -> i + 1)
.filter(n -> {
if (n < 10) {
System.out.println(n);
return false;
} else {
return true;
}
})
.findAny();
于 2015-06-26T01:00:02.870 回答