Myślałem o fajnym sposobie przekonwertowania listy krotek ze zduplikowanym kluczem [("a","b"),("c","d"),("a","f")]
na mapę ("a" -> ["b", "f"], "c" -> ["d"])
. Normalnie (w Pythonie) tworzyłem pustą mapę i pętlę for-for na liście i sprawdzałem, czy nie ma zduplikowanego klucza. Ale szukam tutaj czegoś bardziej skalistego i sprytnego.
btw, rzeczywisty typ klucza i wartości, którego tutaj używam, to (Int, Node)
i chcę przekształcić go w mapę(Int -> NodeSeq)
Map[String, SeqView[String,Seq[_]]]
... czy jest to zamierzone?SeqView[String,Seq[_]]
jest równieżSeq[String]
. Z perspektywy czasu uważam, że to nie jest warte zachodu, więc usunąłemview
.mapValues
i tak zrobi przegląd wartości.x.groupBy(_._1).mapValues(_.map(_._2)).map(identity)
ponieważmapValues
wyrażenie zostanie ponownie obliczone za każdym razem, gdy zostanie użyte. Zobacz issue.scala-lang.org/browse/SI-7005Dla pracowników Google, którym zależy na duplikatach:
implicit class Pairs[A, B](p: List[(A, B)]) { def toMultiMap: Map[A, List[B]] = p.groupBy(_._1).mapValues(_.map(_._2)) } > List("a" -> "b", "a" -> "c", "d" -> "e").toMultiMap > Map("a" -> List("b", "c"), "d" -> List("e"))
źródło
Zaczynając
Scala 2.13
, większość kolekcji jest wyposażona w metodę groupMap , która jest (jak sama nazwa wskazuje) odpowiednikiem (bardziej wydajnym) a,groupBy
po którym następujemapValues
:List("a" -> "b", "c" -> "d", "a" -> "f").groupMap(_._1)(_._2) // Map[String,List[String]] = Map(a -> List(b, f), c -> List(d))
To:
group
elementy s oparte na pierwszej części krotek (część grupowa mapy grupowej )map
s zgrupowane wartości, biorąc ich drugą część krotki (część mapy grupy mapy )Jest to odpowiednik,
list.groupBy(_._1).mapValues(_.map(_._2))
ale wykonywany w jednym przejściu przez listę.źródło
Oto bardziej idiomatyczny sposób Scala na przekonwertowanie listy krotek na mapę obsługującą zduplikowane klucze. Chcesz użyć fałdy.
val x = List("a" -> "b", "c" -> "d", "a" -> "f") x.foldLeft(Map.empty[String, Seq[String]]) { case (acc, (k, v)) => acc.updated(k, acc.getOrElse(k, Seq.empty[String]) ++ Seq(v)) } res0: scala.collection.immutable.Map[String,Seq[String]] = Map(a -> List(b, f), c -> List(d))
źródło
Poniżej znajdziesz kilka rozwiązań. (GroupBy, FoldLeft, Aggregate, Spark)
val list: List[(String, String)] = List(("a","b"),("c","d"),("a","f"))
Grupa według odmian
Odmiana zagięcia w lewo
list.foldLeft[Map[String, List[String]]](Map())((acc, value) => { acc.get(value._1).fold(acc ++ Map(value._1 -> List(value._2))){ v => acc ++ Map(value._1 -> (value._2 :: v)) } })
Zagregowana odmiana - podobnie jak spasowanie w lewo
list.aggregate[Map[String, List[String]]](Map())( (acc, value) => acc.get(value._1).fold(acc ++ Map(value._1 -> List(value._2))){ v => acc ++ Map(value._1 -> (value._2 :: v)) }, (l, r) => l ++ r )
Spark Variation - dla dużych zbiorów danych (konwersja na RDD i zwykłą mapę z RDD)
import org.apache.spark.rdd._ import org.apache.spark.{SparkContext, SparkConf} val conf: SparkConf = new SparkConf().setAppName("Spark").setMaster("local") val sc: SparkContext = new SparkContext (conf) // This gives you a rdd of the same result val rdd: RDD[(String, List[String])] = sc.parallelize(list).combineByKey( (value: String) => List(value), (acc: List[String], value) => value :: acc, (accLeft: List[String], accRight: List[String]) => accLeft ::: accRight ) // To convert this RDD back to a Map[(String, List[String])] you can do the following rdd.collect().toMap
źródło
Możesz tego spróbować
scala> val b = new Array[Int](3) // b: Array[Int] = Array(0, 0, 0) scala> val c = b.map(x => (x -> x * 2)) // c: Array[(Int, Int)] = Array((1,2), (2,4), (3,6)) scala> val d = Map(c : _*) // d: scala.collection.immutable.Map[Int,Int] = Map(1 -> 2, 2 -> 4, 3 -> 6)
źródło