【问题标题】:Traversable => Java Iterator可遍历 => Java 迭代器
【发布时间】:2012-10-22 22:27:58
【问题描述】:

我有一个 Traversable,我想把它变成一个 Java 迭代器。我的问题是我希望一切都懒惰地完成。如果我在可遍历对象上执行 .toIterator,它会急切地产生结果,将其复制到 List 中,并在 List 上返回一个迭代器。

我确定我在这里遗漏了一些简单的东西......

这是一个小测试用例,说明了我的意思:

class Test extends Traversable[String] {
      def foreach[U](f : (String) => U) {
         f("1")
         f("2")
         f("3")
         throw new RuntimeException("Not lazy!")
     }
}

val a = new Test
val iter = a.toIterator

【问题讨论】:

  • 根据源码,toIterator默认实现为:.toStream.iterator是惰性的。
  • @paradigmatic 感谢您的调查。我做了同样的事情,得出了同样的结论,直到我测试它。我添加了一个小测试用例来显示我的问题。
  • @paradigmatic: 是的,但是 toStream 被实现为 toBuffer.toStream

标签: scala scala-collections scala-java-interop


【解决方案1】:

你不能懒惰地从可遍历对象中获取迭代器的原因是你本质上不能。 Traversable 定义了foreach,foreach 贯穿一切,不停歇。没有懒惰。

所以你有两个选择,都是很糟糕的,让它变得懒惰。

首先,您可以每次都遍历整个内容。 (我打算用Scala Iterator,Java Iterator基本一样)

class Terrible[A](t: Traversable[A]) extends Iterator[A] {
  private var i = 0
  def hasNext = i < t.size   // This could be O(n)!
  def next: A = {
    val a = t.slice(i,i+1).head  // Also could be O(n)!
    i += 1
    a
  }
}

如果您碰巧有高效的索引切片,那就没问题了。如果不是,每个“下一个”将花费迭代器长度的线性时间,O(n^2) 时间只是遍历它。但这也不是必要懒惰的;如果你坚持必须是你必须在所有情况下强制执行O(n^2) 并执行

class Terrible[A](t: Traversable[A]) extends Iterator[A] {
  private var i = 0
  def hasNext: Boolean = {
    var j = 0
    t.foreach { a =>
      j += 1
      if (j>i) return true
    }
    false
  }
  def next: A = { 
    var j = 0
    t.foreach{ a => 
      j += 1
      if (j>i) { i += 1; return a }
    }
    throw new NoSuchElementException("Terribly empty")
  }
}

这对于通用代码来说显然是一个糟糕的主意。

另一种方法是使用线程并阻止 foreach 的遍历。没错,您必须对每个元素访问进行线程间通信!让我们看看它是如何工作的——我将在这里使用 Java 线程,因为 Scala 正在转换到 Akka 风格的演员(尽管任何旧演员或 Akka 演员或 Scalaz 演员或 Lift 演员或(等)会起作用)

class Horrible[A](t: Traversable[A]) extends Iterator[A] {
  private val item = new java.util.concurrent.SynchronousQueue[Option[A]]()
  private class Loader extends Thread {
    override def run() { t.foreach{ a => item.put(Some(a)) }; item.put(None) }
  }
  private val loader = new Loader
  loader.start
  private var got: Option[A] = null
  def hasNext: Boolean = {
    if (got==null) { got = item.poll; hasNext }
    else got.isDefined
  }
  def next = {
    if (got==null) got = item.poll
    val ans = got.get
    got = null
    ans
  }
}

这避免了O(n^2) 灾难,但会占用一个线程并且逐个元素的访问速度极慢。我在我的机器上每秒获得大约 200 万次访问,而典型的可遍历则超过 100M。对于通用代码来说,这显然是一个可怕的想法。

所以你有它。一般来说,Traversable 并不懒惰,没有什么好的方法可以让它变得懒惰而不极大地影响性能。

【讨论】:

    【解决方案2】:

    我有run into this problem before,据我所知,当您定义的所有内容都是foreach 时,没有人对更容易获得Iterator 感兴趣。

    但正如您所指出的,toStream 是问题所在,因此您可以直接覆盖它:

    class Test extends Traversable[String] {
      def foreach[U](f: (String) => U) {
        f("1")
        f("2")
        f("3")
        throw new RuntimeException("Not lazy!")
      }
      override def toStream: Stream[String] = {
        "1" #::
        "2" #::
        "3" #::
        Stream[String](throw new RuntimeException("Not lazy!"))
      }
    }
    

    另一种选择是定义Iterable 而不是Traversable,然后您将直接获得iterator 方法。您能否再解释一下您的Traversable 在您的实际用例中做了什么?

    【讨论】:

    • 可悲的是,这对实际的懒惰不起作用。看我的回答。
    • 它在通过测试的意义上确实有效。我同意还有其他问题。
    猜你喜欢
    • 1970-01-01
    • 1970-01-01
    • 2016-09-03
    • 1970-01-01
    • 1970-01-01
    • 1970-01-01
    • 1970-01-01
    • 1970-01-01
    • 1970-01-01
    相关资源
    最近更新 更多