为什么 headOption 更快

Question

我对一些代码进行了更改，它的速度提高了 4.5 倍。我想知道为什么。它曾经本质上是：

def doThing(queue: Queue[(String, String)]): Queue[(String, String)] = queue match {
  case Queue((thing, stuff), _*) => doThing(queue.tail)
  case _ => queue
}

我把它改成这样以获得巨大的速度提升：

def doThing(queue: Queue[(String, String)]): Queue[(String, String)] = queue.headOption match {
  case Some((thing, stuff)) => doThing(queue.tail)
  case _ => queue
}

_* 有什么作用，为什么它比 headOption 贵？

Answer 1

_* 用于指定可变参数，因此您在第一个版本中所做的是将 Queue 解构为一对字符串，以及适当数量的其他字符串对 - 即您正在解构整个 Queue虽然你只关心第一个元素。

如果你只是去掉星号，给

def doThing(queue: Queue[(String, String)]): Queue[(String, String)] = queue match {
  case Queue((thing, stuff), _) => doThing(queue.tail)
  case _ => queue
}

那么您只是将队列解构为一对字符串和一个余数（因此不需要完全解构）。这应该在与您的第二个版本相当的时间内运行（但我自己还没有计时）。

Answer 2

您的代码示例之间应该没有显着差异。

case Queue((thing, stuff), _*)实际上被编译器翻译成调用head(apply(0))方法。您可以使用scalac -Xprint:patmat 对此进行调查：

<synthetic> val p2: (String, String) = o9.get.apply(0);
if (p2.ne(null))
  matchEnd6(doThing(queue.tail))

head的费用和headOption的费用差不多。

方法head、tail 和dequeue 可能会在Queue 的内部List 上导致reverce（成本O(n)）。在您的两个代码示例中，最多会有 2 个 reverce 调用。 您应该像这样使用dequeue 最多获得一个reverce 调用：

def doThing(queue: Queue[(String, String)]): Queue[(String, String)] =
  if (queue.isEmpty) queue
  else queue.dequeue match {
    case (e, q) => doThing(q)
  }

您也可以将(thing, stuff) 替换为_。在这种情况下，编译器将只生成lengthCompare 的调用，而没有head 或tail：

if (o9.get != null && o9.get.lengthCompare(1) >= 0)

Answer 3

我在使用-Xprint:all 运行 scalac 后的猜测是，在 queue match { case Queue((thing, stuff), _*) => doThing(queue.tail) } 示例中 patmat 的末尾，我看到调用了以下方法（为简洁起见进行了编辑）：

val o9 = scala.collection.immutable.Queue.unapplySeq[(String, String)](x1);
if (o9.isEmpty.unary_!)
  if (o9.get.!=(null).&&(o9.get.lengthCompare(1).>=(0)))
    {
      val p2: (String, String) = o9.get.apply(0);
      val p3: Seq[(String, String)] = o9.get.drop(1);

所以lengthCompare 以一种可能优化的方式比较集合的长度。对于Queue，它会创建一个迭代器并迭代一次。所以这应该有点快。另一方面，drop(1) 也构造了一个迭代器，跳过一个元素并将其余元素添加到结果队列中，这样集合的大小将是线性的。

headOption 示例更简单，它检查列表是否为空（两次比较），如果不是则返回 Some(head)，然后将其 _1 和 _2 分配给 thing和stuff。所以没有迭代器被创建，集合的长度也没有任何线性关系。