Java 8 Stream，头和尾

Question

Java 8引入了一个类似于Scala的Stream的Stream类，它是一个强大的惰性构造，使用它可以非常简洁地执行以下操作：

def from(n: Int): Stream[Int] = n #:: from(n+1)

def sieve(s: Stream[Int]): Stream[Int] = {
  s.head #:: sieve(s.tail filter (_ % s.head != 0))
}

val primes = sieve(from(2))

primes takeWhile(_ < 1000) print  // prints all primes less than 1000

我想知道是否可以在Java 8中执行此操作，所以我写了如下代码：

IntStream from(int n) {
    return IntStream.iterate(n, m -> m + 1);
}

IntStream sieve(IntStream s) {
    int head = s.findFirst().getAsInt();
    return IntStream.concat(IntStream.of(head), sieve(s.skip(1).filter(n -> n % head != 0)));
}

IntStream primes = sieve(from(2));

相当简单，但它产生的java.lang.IllegalStateException: stream has already been operated upon or closed原因是findFirst()和skip()都是终端操作，Stream只能在该终端上执行一次。

我真的不需要用完两次流，因为我需要的只是流中的第一个数字，其余作为另一个流，即Scala
Stream.head和的等效项Stream.tail。Java 8 Stream中是否可以使用一种方法来实现此目的？

谢谢。

Answer 1

即使您没有无法分割的问题IntStream，您的代码也不起作用，因为您是sieve递归地而不是惰性地调用方法。因此，在查询结果流中的第一个值之前，您必须进行无穷递归。

可以IntStream s将a分为头和尾IntStream（尚未消耗）：

PrimitiveIterator.OfInt it = s.iterator();
int head = it.nextInt();
IntStream tail = IntStream.generate(it::next).filter(i -> i % head != 0);

在这个地方，您需要sieve懒惰地调用尾部的构造。Stream不提供；concat期望将现有流实例作为参数，并且您不能构造sieve带有lambda表达式的延迟调用的流，因为惰性创建仅在可变状态下才起作用，而lambda表达式不支持这种状态。如果您没有隐藏可变状态的库实现，则必须使用可变对象。但是，一旦您接受了可变状态的要求，该解决方案甚至比第一种方法更容易：

IntStream primes = from(2).filter(i -> p.test(i)).peek(i -> p = p.and(v -> v % i != 0));

IntPredicate p = x -> true;

IntStream from(int n)
{
  return IntStream.iterate(n, m -> m + 1);
}

这将递归地创建一个过滤器，但是最后无论创建一个IntPredicates的树还是一个s的树都没有关系IntStream（就像您的IntStream.concat方法可行一样）。如果您不喜欢过滤器的可变实例字段，则可以将其隐藏在内部类中（而不是在lambda表达式中）。