Scala惯用写法：遍历类Iterator的遗留库数据结构

背景：非标准迭代器类 #

假设有一个行为逻辑和Iterator一致，但未实现Scala标准Iterator接口的遗留类：

class LegacyIterator[T](iterable: Iterable[T]) {
  val iterator: Iterator[T] = iterable.iterator
  def hasNext: Boolean = iterator.hasNext
  def next(): T = iterator.next()
}

val lagIter: LegacyIterator[Int] = new LegacyIterator(List(1, 2, 3))

已实现的两种遍历方式 #

尾递归实现 #

import scala.annotation.tailrec

@tailrec
def lagIterList(accu: List[Int]): List[Int] =
  if (lagIter.hasNext) lagIterList(lagIter.next() :: accu) else accu

val res = lagIterList(Nil).reverse

LazyList惰性遍历实现 #

def ll: LazyList[Int] = if(lagIter.hasNext) lagIter.next() #:: ll else LazyList.empty
val res = ll.toList

哪种更符合Scala惯用风格？ #

LazyList版本更贴合Scala的函数式编程惯用风格：

• Scala的设计核心之一是复用标准集合库的抽象能力，LazyList天然支持惰性计算，能直接对接map、filter等高阶操作，代码简洁且表达性更强。
• 尾递归版本虽然在极端大数据量下可能有微小性能优势，但需要手动维护累加器、最后还要反转结果，代码冗余度高，且无法直接复用集合库的丰富功能，灵活性不足。

其他更优的实现思路 #

1. 适配为标准Iterator接口（最优方案） #

最地道的Scala做法是将遗留迭代器适配成标准Iterator，一次适配即可永久复用所有集合库功能：

implicit def legacyToStandardIterator[T](li: LegacyIterator[T]): Iterator[T] = new Iterator[T] {
  override def hasNext: Boolean = li.hasNext
  override def next(): T = li.next()
}

// 适配后可直接像标准迭代器一样操作
val res = lagIter.toList
val filtered = lagIter.filter(_ > 1).map(_ * 2).toList

这种方式完全契合Scala的接口抽象设计，是长期维护的最佳选择。

2. 利用标准Iterator生成器 #

借助Iterator.continually生成元素流，直到迭代器耗尽：

val res = Iterator.continually(())
  .takeWhile(_ => lagIter.hasNext)
  .map(_ => lagIter.next())
  .toList

代码简洁，无需手动递归或惰性列表，直接复用标准库的迭代器逻辑。

3. 普通递归实现（仅适合小数据集） #

非尾递归版本代码简洁但存在栈溢出风险，仅适用于小规模数据：

def traverse: List[Int] = 
  if (lagIter.hasNext) lagIter.next() :: traverse else Nil

val res = traverse

内容的提问来源于stack exchange，提问作者Zwackelmann