更清洁的元组组

Question

我有一系列键值对(String,Int),我想按键将它们分组为一系列值(即Seq[(String, Int)]) => Map[String, Iterable[Int]])).

显然,toMap这里没用,并将groupBy值保持为元组.我设法得到的最好的是:

val seq: Seq[( String, Int )]
// ...
seq.groupBy( _._1 ).mapValues( _.map( _._2 ) )

这样做有更干净的方法吗？

Answer 1

这是一个toMultiMap为可遍历添加方法的皮条客.它会解决你的问题吗？

import collection._
import mutable.Builder
import generic.CanBuildFrom

class TraversableOnceExt[CC, A](coll: CC, asTraversable: CC => TraversableOnce[A]) {

  def toMultiMap[T, U, That](implicit ev: A <:< (T, U), cbf: CanBuildFrom[CC, U, That]): immutable.Map[T, That] =
    toMultiMapBy(ev)

  def toMultiMapBy[T, U, That](f: A => (T, U))(implicit cbf: CanBuildFrom[CC, U, That]): immutable.Map[T, That] = {
    val mutMap = mutable.Map.empty[T, mutable.Builder[U, That]]
    for (x <- asTraversable(coll)) {
      val (key, value) = f(x)
      val builder = mutMap.getOrElseUpdate(key, cbf(coll))
      builder += value
    }
    val mapBuilder = immutable.Map.newBuilder[T, That]
    for ((k, v) <- mutMap)
      mapBuilder += ((k, v.result))
    mapBuilder.result
  }
}

implicit def commomExtendTraversable[A, C[A] <: TraversableOnce[A]](coll: C[A]): TraversableOnceExt[C[A], A] =
  new TraversableOnceExt[C[A], A](coll, identity)

哪个可以这样使用:

val map = List(1 -> 'a', 1 -> 'à', 2 -> 'b').toMultiMap
println(map)  // Map(1 -> List(a, à), 2 -> List(b))

val byFirstLetter = Set("abc", "aeiou", "cdef").toMultiMapBy(elem => (elem.head, elem))
println(byFirstLetter) // Map(c -> Set(cdef), a -> Set(abc, aeiou))

如果添加以下隐式defs,它也可以用于类似集合的对象,例如Strings和Arrays:

implicit def commomExtendStringTraversable(string: String): TraversableOnceExt[String, Char] =
  new TraversableOnceExt[String, Char](string, implicitly)

implicit def commomExtendArrayTraversable[A](array: Array[A]): TraversableOnceExt[Array[A], A] =
  new TraversableOnceExt[Array[A], A](array, implicitly)

然后:

val withArrays = Array(1 -> 'a', 1 -> 'à', 2 -> 'b').toMultiMap
println(withArrays) // Map(1 -> [C@377653ae, 2 -> [C@396fe0f4)

val byLowercaseCode = "Mama".toMultiMapBy(c => (c.toLower.toInt, c))
println(byLowercaseCode) // Map(97 -> aa, 109 -> Mm)

Answer 2

标准库中没有方法或数据结构来执行此操作,您的解决方案看起来就像您将获得的简洁.如果您在多个地方使用此功能,您可能希望将其分解为实用程序方法

def groupTuples[A,B](seq: Seq[(A,B)]) = 
  seq groupBy (_._1) mapValues (_ map (_._2))

然后你显然只是打电话给你groupTuples(seq).就CPU时钟周期而言,这可能不是最有效的,但我认为它也不是特别低效.

我在9个元组的列表中对Jean-Philippe的解决方案进行了粗略的基准测试,这个速度略快一些.两者的速度都是将序列折叠到地图中的两倍(有效地重新实现groupBy以提供您想要的输出).

Answer 3

我不知道你是否认为它更干净:

seq.groupBy(_._1).map { case (k,v) => (k,v.map(_._2))}