我有一组键值对(String,Int),我想按键将它们分组为一个值序列(即Seq[(String, Int)]) => Map[String, Iterable[Int]])
)。
显然,toMap
在这里没有用处,而 groupBy
会保持元组的值。我能想到的最好解决方案是:
val seq: Seq[( String, Int )]
// ...
seq.groupBy( _._1 ).mapValues( _.map( _._2 ) )
有更简洁的方法吗?
我有一组键值对(String,Int),我想按键将它们分组为一个值序列(即Seq[(String, Int)]) => Map[String, Iterable[Int]])
)。
显然,toMap
在这里没有用处,而 groupBy
会保持元组的值。我能想到的最好解决方案是:
val seq: Seq[( String, Int )]
// ...
seq.groupBy( _._1 ).mapValues( _.map( _._2 ) )
有更简洁的方法吗?
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))
String
和Array
:
如果您添加以下隐式定义,它也将适用于类似于集合的对象,例如String
和Array
:
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)
List(1 -> 'a',1 -> 'à',2 -> 'b')
,但我希望toMultiMap
的结果是Map[Int,Set[String]]
?也许可以用breakOut
做些小技巧? - Tomáš Dvořák标准库中没有相应的方法或数据结构可以做到这一点,你的解决方案看起来就像你能得到的最简洁的解决方案。如果你在多个地方使用它,你可能会想把它提取出来成为一个实用方法。
def groupTuples[A, B](seq: Seq[(A, B)]) =
seq groupBy (_._1) mapValues (_ map (_._2))
然后你显然只需调用 groupTuples(seq)
即可。从 CPU 时钟周期的角度来看,这可能不是最高效的方法,但我认为它也不是特别低效。
我对一个由9个元组组成的列表进行了简单的基准测试,这比 Jean-Philippe 的解决方案略快一些。两者都比将序列折叠到映射(有效地重新实现 groupBy
来给出所需输出)要快大约两倍。
mapValues
实际上只是包装了构建的映射,因此在查找映射中的内容时可能效率会降低。另外,我已经编辑了我的答案,避免了使用toMap
;出于好奇,您可以再次运行相同的基准测试吗?根据我的基准测试,对于9个元组,使用我的提议构建映射和两次查找时间约为原来的三分之一。 - Jean-Philippe PelletmapValues
包装了现有的 map - 我不知道这一点。使用 seq groupBy (_._1) map (x => (x._1, x._2 map (_._2)))
创建一个全新的 map 需要 165 毫秒,因此对于在内存中创建新的 map,你的方法更快。 - Luigi Plinge我不知道你是否认为它更加清晰:
seq.groupBy(_._1).map { case (k,v) => (k,v.map(_._2))}
List(1 -> 'a', 1 -> 'b', 2 -> 'c').groupMap(_._1)(_._2)
// Map[Int,List[Char]] = Map(2 -> List(c), 1 -> List(a, b))
这样做:
group
根据元组的第一部分(Map(2 -> List((2,c)), 1 -> List((1,a), (1,b)))
)将元素分组。
map
通过获取其第二个元组部分(List(a, b)
)来 map
分组后的值(List((1,a), (1,b))
)。