Convertir Liste de tuple à la carte (et de traiter avec le double de la clé ?)

Je pensais à une belle façon de convertir une Liste de tuple avec le double de la clé [("a","b"),("c","d"),("a","f")] en map ("a" -> ["b", "f"], "c" -> ["d"]). Normalement (en python), j'aimerais créer une carte vide et en boucle sur la liste et cochez pour dupliquer une clé. Mais je suis à la recherche de quelque chose de plus scala-ish et solution intelligente ici.

btw, type réel de la valeur-clé que j'utilise ici est (Int, Node) et je veux tourner dans un plan de (Int -> NodeSeq)

InformationsquelleAutor Tg. | 2011-11-04

map scala

Groupe et le projet:

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

Plus scalish façon d'utiliser le pli, en la manière que il y (sauter map f étape).

InformationsquelleAutor om-nom-nom

111

Pour les Googlers qui n'attendent pas de doublons ou bien avec la par défaut en double manipulation politique:
```
List("a" -> 1, "b" -> 2).toMap
//Result: Map(a -> 1, c -> 2)
```
De 2.12, la politique par défaut de lit:

Des doubles de clés seront remplacées plus tard par des touches: si c'est une collection non ordonnée, dont la clé est dans la carte qui n'est pas défini.

InformationsquelleAutor Cory Klein
52

Voici une autre alternative:
```
x.groupBy(_._1).mapValues(_.map(_._2))
```
- Cela nous donne une Map[String, SeqView[String,Seq[_]]]... est-ce intentionnel?
- Un SeqView[String,Seq[_]] est aussi un Seq[String]. Toujours avec le recul, je ne pense pas que c'est utile, j'ai donc enlevé le view. mapValues fera une vue de toute façon sur les valeurs.
- De ce fait le travail parfaitement pour mon cas (coursera devoirs): paresseux val dictionaryByOccurrences: Carte[Occurrences, Liste[Mot]] = { val paires = pour (curWord <- dictionnaire) rendement { val curWordOccurrences = wordOccurrences(curWord) (curWordOccurrences, curWord) } paires.groupBy(._1).mapValues(.map(_._2)) }
- mapValues renvoie une vue de la carte, et pas une nouvelle carte scala-lang.org/api/current/index.html#scala.collection.Map
- Voulez probablement x.groupBy(_._1).mapValues(_.map(_._2)).map(identity) parce que le mapValues expression sera recalculée chaque fois qu'il est utilisé. Voir issues.scala-lang.org/browse/SI-7005
InformationsquelleAutor Daniel C. Sobral

Pour les Googlers qui ne se soucient de 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"))

InformationsquelleAutor pathikrit

5

De départ Scala 2.13, la plupart des collections sont fournis avec la groupMap méthode qui est (comme son nom l'indique) un équivalent (plus efficace) d'un groupBy suivie par 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 des éléments basés sur la première partie de n-uplets (groupe partie de groupeCarte)
- maps groupées des valeurs en prenant leur deuxième tuple partie (carte de la partie de groupe deCarte)
C'est un équivalent de list.groupBy(_._1).mapValues(_.map(_._2)) mais réalisée en un seul passage par le biais de la Liste.

InformationsquelleAutor Xavier Guihot
4

Ici est un Scala idiomatiques moyen de convertir une liste de tuples d'une carte de la manipulation des doubles des clés. 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))
```
- Pourquoi vous pensez que c'est plus de la Scala de style que le groupBy-mapValue solutions fournies ici?
- déclaration "Plus scalish façon d'utiliser le pli, en la manière que il (passer de la carte étape f)."
- Je m'attendais à une logique de l'argument ;-). Ni om-nom-nom, ni l'article lié fourni des éléments de preuve pour ma question. (Ou alors j'ai manqué ça?)
- C'est un plus fp façon de traiter avec cela, puisque toutes les monades sont monoids, et monoids par la loi sont pliables. En pf, les objets et les événements sont modélisés comme des monades, et non pas toutes les monades mettra en œuvre groupBy.
InformationsquelleAutor cevaris

Ci-dessous vous pouvez trouver quelques solutions. (GroupBy, FoldLeft, D'Agrégation, De L'Étincelle)

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

GroupBy variation

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

Pli à Gauche de la variation

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

Globale Variations Similaires à plier 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
)

Étincelle Variation - Pour les grands ensembles de données (Conversion d'un CA et d'une simple Carte 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

InformationsquelleAutor Melcom van Eeden

Vous pouvez essayer ce

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)

InformationsquelleAutor frankfzw

Vous devez vous connecter pour publier un commentaire.