У меня есть последовательность пар ключ-значение (String, Int), и я хочу сгруппировать их ключом в последовательность значений (т.е. Seq[(String, Int)]) => Map[String, Iterable[Int]])).
Очевидно, что toMap здесь бесполезно, а groupBy поддерживает значения как кортежи. Лучшее, что мне удалось найти, это:
val seq: Seq[( String, Int )]
// ...
seq.groupBy( _._1 ).mapValues( _.map( _._2 ) )
Есть ли более чистый способ сделать это?
Здесь сутенер, который добавляет метод 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, он также будет работать с такими коллекционными объектами, как String и Array s:
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 -> [[email protected], 2 -> [[email protected])
val byLowercaseCode = "Mama".toMultiMapBy(c => (c.toLower.toInt, c))
println(byLowercaseCode) // Map(97 -> aa, 109 -> Mm)
В стандартной библиотеке нет метода или структуры данных, и ваше решение выглядит так же кратким, как вы получите. Если вы используете это более чем в одном месте, вы можете включить его в утилиту
def groupTuples[A,B](seq: Seq[(A,B)]) =
seq groupBy (_._1) mapValues (_ map (_._2))
который вы, очевидно, просто вызываете с помощью groupTuples(seq). Это может быть не самым эффективным в плане тактовых циклов процессора, но я не думаю, что это особенно неэффективно.
Я сделал приблизительный тест против решения Жана-Филиппа в списке из 9 кортежей, и это немного быстрее. Оба были примерно в два раза быстрее, чем складывание последовательности в карту (эффективно повторное внедрение groupBy, чтобы дать желаемый результат).
Я не знаю, считаете ли вы его более чистым:
seq.groupBy(_._1).map { case (k,v) => (k,v.map(_._2))}