我可以计算此 Scala 片段中 1 个循环中的出现次数吗？

Question

我有一段简单的 Scala 代码。我按顺序循环遍历字符串列表，并且我想计算列表 r 中作为元组 (String, Int) 收集的每个字符串的出现次数。主函数中的部分应该保留（所以没有groupBy之类的东西）。我的问题是关于更新函数：

现在我首先执行 find ，然后向 r 添加一个新元组（如果它不存在）。如果确实存在，我会循环遍历 r 并更新匹配字符串的计数器。

能否修改更新函数，使其更加高效？ r 可以在单次迭代中更新吗（如果不存在则添加，如果存在则更新计数器）？

谢谢

var r = List[(String, Int)]() // (string, count)

def update(s: String, l: List[(String, Int)]) : List[(String, Int)] = {
  if (r.find(a => a._1  == s) == None) {
    (s, 1) :: r // add a new item if it does not exist
  } else {
    for (b <- l) yield {
      if (b._1 == s) {
        (b._1, b._2 + 1) // update counter if exists
      } else {
        b // just yield if no match
      }
    }
  }
}

def main(args : Array[String]) : Unit = {
  val l = "A" :: "B" :: "A" :: "C" :: "A" :: "B" :: Nil

  for (s <- l) r = update(s, r)

  r foreach println
}

Answer 1

像这样的东西也有效：

val l = List("A","B","A","C","A","B")

l.foldLeft(Map[String,Int]()) {
  case (a: Map[String, Int], s: String) => {
    a + (s -> (1 + a.getOrElse(s, 0)))
  }
}

res3: scala.collection.immutable.Map[String,Int] = Map((A,3), (B,2), (C,1))

Answer 2

您当前的解决方案非常慢，主要是因为选择 r 作为 List。但至少在更新的情况下您在整个列表中的迭代可以得到改进。我会这样写，

def update(s: String, l: List[(String, Int)]) : List[(String, Int)] = {
  l span (_._1 != s) match {
    case (before, (`s`, count) :: after) => before ::: (s, count + 1) :: after
    case _ => (s, 1) :: l
  }
}

使用 span 可以避免搜索列表两次。此外，我们只需追加after，而不必再次迭代它。

Answer 3

我建议您选择函数式风格并使用 Scala 集合的强大功能：

ss.groupBy(identity).mapValues(_.size)

Answer 4

如果您不想使用 groupBy 或使用惰性集合（流），这可能是要走的路：

ss.foldLeft(Map[String, Int]())((m, s) => m + (s -> (m.getOrElse(s, 0) + 1)))