Scala,Erastothenes：有一种直接用迭代替换流的方法吗？

def primes(): Stream[Int] = {
  def merge(a: Stream[Int],b: Stream[Int]): Stream[Int] = {
    def next = a.head min b.head
    Stream.cons(next,merge(if (a.head == next) a.tail else a,if (b.head == next) b.tail else b))
  }
  def test(n: Int,compositeStream: Stream[Int]): Stream[Int] = {
    if (n == compositeStream.head) test(n+1,compositeStream.tail)
    else Stream.cons(n,test(n+1,merge(compositeStream,Stream.from(n*n,n))))
  }
  test(2,Stream.from(4,2))
}

但是,当我尝试生成第1000个素数时,我得到了“java.lang.OutOfMemoryError：GC开销超出限制”.

我有一个替代解决方案,它在素数上返回一个迭代器,并在内部使用元组的优先级队列(multiple,prime用于生成多个)来标记即将到来的复合.它运行良好,但它需要大约两倍的代码,我基本上不得不从头重新开始：

import scala.collection.mutable.PriorityQueue
def primes(): Iterator[Int] = {
  // Tuple (composite,prime) is used to generate a primes multiples
  object CompositeGeneratorOrdering extends Ordering[(Long,Int)] {
    def compare(a: (Long,Int),b: (Long,Int)) = b._1 compare a._1
  }
  var n = 2;
  val composites = PriorityQueue(((n*n).toLong,n))(CompositeGeneratorOrdering)
  def advance = {
    while (n == composites.head._1) { // n is composite
      while (n == composites.head._1) { // duplicate composites
        val (multiple,prime) = composites.dequeue
        composites.enqueue((multiple + prime,prime))
      }
      n += 1
    }
    assert(n < composites.head._1)
    val prime = n
    n += 1
    composites.enqueue((prime.toLong * prime.toLong,prime))
    prime
  }
  Iterator.continually(advance)
}

有没有一种直接的方法将带有流的代码转换为带迭代器的代码？或者有一种简单的方法可以让我的第一次尝试更有效率吗？

从流中考虑更容易;我宁愿那样开始,然后在必要时调整我的代码.