1) p 是什么意思？
groupBy 采用一个函数，该函数将元素映射到 K 类型的键。当在某个集合 Coll 上调用时，它会返回一个 Map[K, Coll]，其中包含从键 K 到映射到同一键的所有元素的映射。
因此，在您的情况下，str.groupBy(_.toChar) 生成从键 k（这是一个字符）到包含所有元素（字符）c 的字符串的映射映射，例如 k == c.toChar。
你得到这个：
Map(e -> "e", h -> "h", l -> "ll", o -> "o")
Map 是键和值对的可迭代对象。在这种情况下，每一对都是一个字符和一串元素。在Map 上调用map 操作涉及到这些对的映射——p 是一对其中p._1 是一个字符，p._2 是关联的字符串（您可以在其上调用length，如你在上面做了）。
2) 如何以惯用方式做到这一点
以上是如何使用惯用的方法 - 使用 groupBy 和 map。或者，您可以使用不可变映射和对字符串长度的递归来计算频率，或者使用不可变映射和 foldLeft。
3) 性能特点
最好 benchmark 看看差异。
这里有几个针对高重复字符串的微基准测试（~3GHz iMac、JDK7、Scala 2.10.0 nightly）：
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
请注意，将命令式版本更改为使用withDefaultValue：
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
}
由于转发每个 put 呼叫，显然非常慢：
-
withDefaultValue: $ 133 87 109 106 101 100 101 100 101 101
结论：在这种情况下，字符的装箱和拆箱已经足够高，因此很难观察到这些方法之间的性能差异。
编辑：
更新：您可能希望使用 ScalaMeter inline benchmarking 代替 Benchmark 特征。