Java 8 如何使用Java8创建无限流

有没有一种简单的方法可以在不使用外部库的情况下创建无限流

例如，在Scala中：

Iterator.iterate(0)(_ + 2)

以下是一个例子：

PrimitiveIterator.OfInt it = new PrimitiveIterator.OfInt() {
    private int value = 0;

    @Override
    public int nextInt() {
        return value++;
    }

    @Override
    public boolean hasNext() {
        return true;
    }
};

Spliterator.OfInt spliterator = Spliterators.spliteratorUnknownSize(it,
    Spliterator.DISTINCT | Spliterator.IMMUTABLE |
    Spliterator.ORDERED | Spliterator.SORTED);

IntStream stream = StreamSupport.intStream(spliterator, false);

正如你所看到的，这有点冗长。要打印此流的前10个元素：

stream.limit(10).forEach(System.out::println);

当然，您也可以变换元素，就像您在Scala示例中所做的那样：

IntStream plusTwoStream = stream.map(n -> n + 2);

---

请注意，有内置的无限流，例如

java.util.Random.ints（）

，它提供无限的随机整数流。

是的，有一种简单的方法：

IntStream.iterate(0, i -> i + 2);

作为用例：

IntStream.iterate(0, i -> i + 2)
         .limit(100)
         .forEach(System.out::println);

以2的步长递增，打印出0到198

一般方法是：

Stream.iterate(T seed, UnaryOperator<T> f);

Stream.iterate（T种子，一元运算符f）；

---

后者在使用上可能更不常见。

您可以通过实现流和消费者来构建自己的InfiniteStream，并将两者组合在一起，并且可能需要队列将数据排队，如下所示：

public class InfiniteStream<T> implements Consumer<T>, Stream<T> {
private final Stream<T> stream;
private final Queueing q;
...
public InfiniteStream(int length) {
    this.q = new Queueing(this.length);
    this.stream = Stream.generate(q);
    ...
}
    //implement stream methods
    //implement accept
}

public类InfiniteStream实现消费者、流{
私有最终流；
私有最终排队q；
...
公共无穷大字符串（整数长度）{
this.q=新排队（this.length）；
this.stream=stream.generate（q）；
...
}
//实现流方法
//实现接受
}

在这里检查完整代码

---

在Java 8中还有另一种可能的解决方案：

AtomicInteger adder = new AtomicInteger();
IntStream stream = IntStream.generate(() -> adder.getAndAdd(2));

static IntStream iterate​(int seed,
                         IntPredicate hasNext,
                         IntUnaryOperator next);

重要提示：仅当流是连续的时，才会保留数字顺序

---

还值得注意的是，自Java 9以来，添加了新版本的：

AtomicInteger adder = new AtomicInteger();
IntStream stream = IntStream.generate(() -> adder.getAndAdd(2));

static IntStream iterate​(int seed,
                         IntPredicate hasNext,
                         IntUnaryOperator next);

• 种子-初始元素
• hasNext—应用于元素以确定流何时必须终止的谓词
• next—应用于上一个元素以生成新元素的函数

示例：

IntStream stream = IntStream.iterate(0, i -> i >= 0, i -> i + 2);

IntStream.iterate(0, i -> i < 10, i -> i + 2).forEach(System.out::println);

IntStream=IntStream.iterate（0，i->i>=0，i->i+2）；
迭代（0，i->i<10，i->i+2）.forEach（System.out:：println）；

给定它的

原语迭代器

，一个简单的

IntStream.generate（it:：next）

也可以工作。因此它甚至不必是一个迭代器，例如，

IntStream.generate（new AtomicInteger（）：：incrementAndGet）

也将提供这样一个自然的数字序列。是的，显然我的解决方案比必要的要详细得多，而且有多种方法可以实现。我不知道

java.util.Random.ints（）

，+1+1，但是值得一提的是，

IntStream.generate

可以在

IntStream.iterate

不适合时使用，例如Fibonacci序列。how

IntStream.iterate

不适合

Fibonacci

？@AsifMushtaq你能提供一个Fibonacci数流与

IntStream.iterate

的关系吗？