为Scala中的字符串生成频率映射

groupBy采用一个将元素映射到K类型的键的功能。当在一些集合Coll上调用时，它返回一个Map [K，Coll]，它包含从K键到映射到同一个键的所有元素的映射。

所以，在你的情况下，str.groupBy(_。toChar)产生从一个键k(它是一个字符)到具有所有元素(字符)c的字符串的映射映射，使得k == c.toChar。
你得到这个：

Map(e -> "e",h -> "h",l -> "ll",o -> "o")

地图是一组可重复的键和值。在这种情况下，每对都是一个字符和一串元素。在地图上调用地图操作涉及对这些对的映射 – p是一对p._1是一个字符，p._2是相关联的字符串(可以在其上调用长度，如上所述)。

2)如何做这个惯用的

以上是如何做成语 – 使用groupBy和map。或者，您可以使用字符串长度上的不可变地图和递归来计算频率，或使用不可变地图和foldLeft。

3)性能特点

最好到benchmark看到差异。
这是一个高度重复的字符串(?3GHz iMac，JDK7，Scala 2.10.0夜间)的几个微型基准：

object Imperative extends testing.Benchmark {
  val str = "abc" * 750000

  def run() {
    var counts = new scala.collection.mutable.HashMap[Char,Int]
    var i = 0
    val until = str.length
    while (i < until) {
      var c = str(i)
      if (counts.contains(c))
        counts.put(c,counts(c) + 1)
      else
        counts.put(c,1)
      i += 1
    }

    //println(f)
  }
}


object Combinators extends testing.Benchmark {
  val str = "abc" * 750000

  def run() {
    val f = str.groupBy(_.toChar).map(p => (p._1,p._2.length))
  }
}


object Fold extends testing.Benchmark {
  val str = "abc" * 750000

  def run() {
    val f = str.foldLeft(Map[Char,Int]() withDefaultValue 0){(h,c) => h.updated(c,h(c)+1)}
  }
}

结果：

>势在必行：$ 103 57 53 58 53 53 53 53 53 53
>组合者：$ 72 51 63 56 53 52 52 54 53 53
>折叠：$ 163 62 71 62 57 57 57 58 57 57

请注意，将命令式版本更改为使用DefaultValue：

var counts = new scala.collection.mutable.HashMap[Char,Int].withDefaultValue(0)
var i = 0
val until = str.length
while (i < until) {
  var c = str(i)
  counts.put(c,counts(c) + 1)
  i += 1
}

由于转发每个拨打电话显然非常慢：

> withDefaultValue：$ 133 87 109 106 101 100 101 100 101 101

结论：在这种情况下，字符的拳击和拆箱是足够高的，所以这些方法之间的性能差异很难观察。

编辑：

更新：您可能要使用ScalaMeter inline benchmarking代替基准特征。