Convertir la liste de tuple en mappage (et gérer la clé en double?)

Je réfléchissais à un bon moyen de convertir une liste de tuple avec une clé en double [("a","b"),("c","d"),("a","f")] en en carte ("a" -> ["b", "f"], "c" -> ["d"]). Normalement (en python), je créerais une carte vide et une boucle for sur la liste et vérifierais la clé en double. Mais je recherche quelque chose de plus scala-ish et de solution intelligente ici.

btw, le type réel de valeur-clé que j'utilise ici est (Int, Node)et je veux devenir une carte de(Int -> NodeSeq)

Grouper puis projeter:

scala> val x = List("a" -> "b", "c" -> "d", "a" -> "f")
//x: List[(java.lang.String, java.lang.String)] = List((a,b), (c,d), (a,f))
scala> x.groupBy(_._1).map { case (k,v) => (k,v.map(_._2))}
//res1: scala.collection.immutable.Map[java.lang.String,List[java.lang.String]] = Map(c -> List(d), a -> List(b, f))

Manière plus évolutive d'utiliser le pli, comme ici (sautez l' map fétape).

Pour les Googleurs qui ne s'attendent pas à des doublons ou qui acceptent la politique de gestion des doublons par défaut :

List("a" -> 1, "b" -> 2).toMap
// Result: Map(a -> 1, c -> 2)

À partir de 2.12, la politique par défaut se lit comme suit:

Les clés en double seront écrasées par les clés ultérieures: s'il s'agit d'une collection non ordonnée, quelle clé se trouve dans la carte résultante n'est pas définie.

Voici une autre alternative:

x.groupBy(_._1).mapValues(_.map(_._2))

Pour les Googleurs qui se soucient des doublons:

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")) 

Au départ Scala 2.13, la plupart des collections sont fournies avec la méthode groupMap qui est (comme son nom l'indique) un équivalent (plus efficace) d'un groupBysuivi de mapValues:

List("a" -> "b", "c" -> "d", "a" -> "f").groupMap(_._1)(_._2)
// Map[String,List[String]] = Map(a -> List(b, f), c -> List(d))

Ce:

• groups éléments basés sur la première partie des tuples (partie de groupe de la carte de groupe )

• maps valeurs groupées en prenant leur deuxième partie de tuple (partie map du groupe Map )

Ceci est un équivalent de list.groupBy(_._1).mapValues(_.map(_._2))mais effectué en un seul passage dans la liste.

Voici une manière plus idiomatique Scala de convertir une liste de tuples en une carte gérant les clés en double. Vous souhaitez utiliser un pli.

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))

Vous trouverez ci-dessous quelques solutions. (GroupBy, FoldLeft, Aggregate, Spark)

val list: List[(String, String)] = List(("a","b"),("c","d"),("a","f"))

Variation GroupBy

list.groupBy(_._1).map(v => (v._1, v._2.map(_._2)))

Plier la variante gauche

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))
  }
})

Variation agrégée - Similaire au pli à gauche

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
)

Variation Spark - Pour les ensembles de données volumineux (conversion en RDD et en carte simple à partir de 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

Vous pouvez essayer ceci

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)