Scala 将迭代方法转换为 Iterator 的函数方法

Question

我有以下函数处理一系列搜索事件，如果它们相关，这些事件需要在搜索流中组合在一起。

  def split(eventsIterator: Iterator[SearchFlowSearchEvent]): Iterator[SearchFlow] = {

    val sortedEventsIterator = eventsIterator.toList.sortBy(_.evTimeMillis).iterator


    val searchFlowsEvents: mutable.MutableList[mutable.MutableList[SearchFlowSearchEvent]] = mutable.MutableList()
    var currentSearchFlowEvents: mutable.MutableList[SearchFlowSearchEvent] = mutable.MutableList()
    var previousEvent: SearchFlowSearchEvent = null
    while (sortedEventsIterator.hasNext) {
      val currentEvent = sortedEventsIterator.next()

      if (isSameFlow(previousEvent, currentEvent)) {
        currentSearchFlowEvents += currentEvent
      } else {
        currentSearchFlowEvents = mutable.MutableList()
        currentSearchFlowEvents += currentEvent
        searchFlowsEvents += currentSearchFlowEvents
      }

      previousEvent = currentEvent
    }


    searchFlowsEvents
      .map(searchFlowEvents => model.SearchFlow(searchFlowEvents.toList))
      .iterator
  }

执行上面列出的事件分组的方法是迭代的（我来自 Java 世界）。

任何人都可以提供一些关于如何以功能方式实现相同结果的提示吗？

Answer 1

这种事情，你要使用尾递归：

        @tailrec 
        def groupEvents(
          in: Iterator[SearchFlowSearchEvent],
          out: List[List[SearchFlowSearchEvent]] = Nil
        ): List[List[SearchFlowSearchEvent]] = if (in.hasNext) {
          val next = in.next
          out match {
            case Nil => groupEvents(in, List(List(next)))
            case (head :: tail) :: rest if isSameFlow(head, next) => groupEvents(in, (next :: head :: tail) :: rest)
            case rest => groupEvents(in, List(next) :: rest)
          }
       } else out.map(_.reverse).reverse 

out 包含到目前为止收集的组（以相反的顺序 - 见下文）。 如果它是空的，只需启动一个新的。否则查看第一个元素（最后一个组），并检查那里的第一个元素（最后一个事件）。如果流程相同，则将当前事件添加到该组，否则添加一个新组。重复。

最后（如果迭代器为空），反转列表并创建流。

在这种情况下，在 scala 中以相反的顺序组装列表是很常见的。这是因为追加到链表的末尾（或查看最后一个元素）需要线性时间，这会使整个操作变成二次的。相反，我们总是在前面添加（恒定时间），然后在最后反转（线性）。

或者，您可以使用foldLeft 编写相同的内容，但就个人而言，我发现在这种情况下递归实现更清晰一些，尽管更长一点（在功能上，它们是等效的）：

    in.foldLeft[List[List[SearchFlowSearchEvent]]](Nil) {
       case (Nil, next) => List(List(next))
       case ((head :: tail) :: rest, next) if isSameFlow(head, next) => 
          (next :: head :: tail) :: rest
       case (rest, next) => List(next) :: rest
    }.map { l => SearchFlow(l.reverse) }.reverse

更新 为了解决性能问题，在 cmets 中向其他帖子提出。我在 MacBook Pro、Mac OS 10.13.5、2.9 GHz i7、16G RAM 和 scala 2.11.11（默认 REPL 设置）上对这三种解决方案进行了基准测试。

输入是 100000 个事件，这些事件被折叠成 14551 个组。 热身后我运行每个实现大约 500 次，并取所有执行的平均时间。

最初的实现每次运行大约需要 42 毫秒。 递归算法大约需要28ms FoldLeft 大约是 29 毫秒

简单地对事件数组进行排序并将其转换为迭代器大约需要 20 毫秒。

我希望这能解决程序方法是否总是比函数方法产生更好的性能的争论。 有一种方法可以通过进行特定的更改和权衡来加速此实现，但简单地用循环替换递归或切换到使用可变容器并不是一种优化。

Answer 2

据我所知，收藏库中没有简单的内置解决方案。正如@Dima 所说，您应该为此使用递归。

请注意，如果您非常关心性能，那么使用 var 和 mutable 集合的初始解决方案可能是最快的。只要你有充分的理由并且只要突变保持在特定方法的本地，可变性就很好。

为了让我自己非常清楚，我不鼓励您对其进行微优化，除非您有一个基准表明这可以以不可忽略的方式帮助您的应用程序的性能。