Liste der Tupel in Map konvertieren (und mit doppeltem Schlüssel umgehen?)

Ich dachte über eine gute Möglichkeit nach, eine Liste von Tupeln mit doppeltem Schlüssel [("a","b"),("c","d"),("a","f")]in eine Karte umzuwandeln ("a" -> ["b", "f"], "c" -> ["d"]). Normalerweise (in Python) würde ich eine leere Map erstellen und die Liste for-loopen und nach doppelten Schlüsseln suchen. Aber ich bin hier auf der Suche nach einer etwas schäbigeren und klügeren Lösung.

Übrigens ist der tatsächliche Typ des Schlüsselwerts, den ich hier verwende, (Int, Node)und ich möchte mich in eine Karte von verwandeln(Int -> NodeSeq)

Gruppe und dann Projekt:

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

Skaliertere Art, Fold zu verwenden, wie dort ( map fSchritt überspringen ).

Für Googler, die keine Duplikate erwarten oder mit der Standardrichtlinie für die Behandlung von Duplikaten einverstanden sind :

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

Ab 2.12 lautet die Standardrichtlinie:

Doppelte Schlüssel werden durch spätere Schlüssel überschrieben: Wenn es sich um eine ungeordnete Sammlung handelt, ist der Schlüssel in der resultierenden Zuordnung undefiniert.

Hier ist eine andere Alternative:

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

Für Googler, die sich für Duplikate interessieren:

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

Beginnend Scala 2.13werden die meisten Sammlungen mit der groupMap- Methode bereitgestellt , die (wie der Name schon sagt) einer äquivalenten (effizienteren) Methode entspricht, groupBygefolgt von mapValues:

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

Dies:

• groups Elemente basierend auf dem ersten Teil von Tupeln (Gruppenteil von Gruppenzuordnung )

• mapgruppierte Werte s mit ihrem zweiten Tupel teilnimmt (Teil der Gruppe Karte Karte )

Dies entspricht, wird list.groupBy(_._1).mapValues(_.map(_._2))jedoch in einem Durchgang durch die Liste ausgeführt.

Hier ist eine Scala-idiomatischere Möglichkeit, eine Liste von Tupeln in eine Karte zu konvertieren, die doppelte Schlüssel verarbeitet. Sie möchten eine Falte verwenden.

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

Nachfolgend finden Sie einige Lösungen. (GroupBy, FoldLeft, Aggregate, Spark)

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

Variation links falten

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

Aggregierte Variation - Ähnlich wie links falten

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 - Für große Datenmengen (Konvertierung in eine RDD und in eine einfache Karte von 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

Sie können dies versuchen

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)