在计算Scala中所有可能的组合时，如何避免java.lang.OutOfMemoryError异常？

我知道有很多关于

java.lang.OutOfMemoryError的相关问题：GC开销限制超过了

（例如），我知道我的问题是由我的错误实现引起的，但我不知道如何修复它

所以，我的目标是从列表中获得所有可能的重复组合。我通过使用MarkLister在本文中提出的代码来完成这项任务。它工作得很好，但显然，使用包含52个元素的列表来获得10个范围内的所有组合对我的计算机来说太多了。有没有办法解决这个问题

可能比仅仅收集大量的

组合列表

s更好，我可以在生成组合时处理每个

单词

这是我的密码：

object MyApp extends App {

  val letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".toList

  run(10)

  def mycomb[T](n: Int, l: List[T]): List[List[T]] =
    n match {
      case 0 => List(List())
      case _ => for (el <- l;
                     sl <- mycomb(n - 1, l dropWhile {
                       _ != el
                     }))
        yield el :: sl
    }

  def comb[T](n: Int, l: List[T]): List[List[T]] = mycomb(n, l.distinct)

  def run(n: Int): Unit = {

    for (i <- 1 to n) {
      val combo = comb(i, letters)

      combo.par.foreach { word =>
        println(word.mkString(""))
        // Process each word one by one in parallel
      }
    }
  }

}

对象MyApp扩展应用程序{
val letters=“abcdefghijklmnopqrstuvxyzabefghijklmnopqrstuvxyz”。toList
跑步（10）
def mycomb[T]（n:Int，l:List[T]）：List[List[T]]=
n匹配{
案例0=>List（List（））
对于（el我找到了一些时间和我的解决方案，用于所有可能的组合，无需重复：

val digits=“abcdefghijklmnopqrstuvxyzabcdefghijklmnopqrstuvxyz”
def concat[T]（it1:Iterator[T]，it2:=>迭代器[T]）：迭代器[T]=新迭代器[T]{
def hasNext:Boolean=it1.hasNext | | it2.hasNext
def next（）：T=if（it1.hasNext）{
it1.next（）
}否则{
it2.next（）
}
}
不带重复的def组合[T]（k:Int，seq:seq[T]）：迭代器[seq[T]={
def组合（k:Int，acc:Seq[T]，tail:Seq[T]）：迭代器[Seq[T]]=k匹配{
案例0=>
迭代器.empty
案例1=>
tail.iterator.map{t=>t+:acc}
如果tail.nonEmpty=>
val it1=组合（k-1，tail.head+：acc，tail.tail）
lazy val it2=组合（k，Seq.empty，tail.tail）
康卡特（it1、it2）
案例=>
迭代器.empty
}
组合（k，序号空，序号）
}
//试验
val iterator=combinationwithout repeats（10，digits.toSeq）//它应该立即返回
println（s“${iterator.next（）}”）
println（s“${iterator.next（）}”）
无重复的组合（2位，到相等）。foreach{
el=>println（s“$el”）
}

我使用了惰性加载。函数concat从两个迭代器中创建迭代器-第一个迭代器由第一个迭代器迭代，当这个迭代器为空时-第二个迭代器开始迭代

更新

重复组合（基于先前功能）：

def组合与重复[T]（k:Int，sequence:Seq[T]）：迭代器[Seq[T]=新迭代器[Seq[T]]{
val不带=组合不带重复（k，序列）
变量组合：迭代器[Seq[T]]=Iterator.empty
def hasNext:布尔={
组合.hasNext | |不带.hasNext
}
def next（）：Seq[T]={
if（composition.isEmpty）{
组合=不带.next（）.置换
}
组合。下一个（）
}
}
你最好是一个）使用不产生重复项的策略，b）在得到结果时输出每个结果。这样你就不会耗尽内存。@PeterLawrey，正是这样，这就是我所想的！我这样做是因为我最初认为我可以对
.par
使用并发方法。使用流或迭代器而不是列表[def组合（n:Int）：Iterator[Seq[A]]]（）@AndrzejJozwik谢谢你的评论。不幸的是，我是Scala初学者。你能提供一个代码示例吗？