Scala beste Möglichkeit, eine Sammlung in eine Map-by-Key zu verwandeln?

Wenn ich eine Sammlung cvon Typen habe Tund eine Eigenschaft pfür T(z P. B. Typ ) vorhanden ist, wie kann ich einen Map-by-Extracting-Key am besten erstellen ?

val c: Collection[T]
val m: Map[P, T]

Ein Weg ist der folgende:

m = new HashMap[P, T]
c foreach { t => m add (t.getP, t) }

Aber jetzt brauche ich eine veränderbare Karte. Gibt es eine bessere Möglichkeit, dies so zu tun, dass es in einer Zeile steht und ich eine unveränderliche Karte erhalte ? (Natürlich könnte ich das oben genannte in ein einfaches Bibliotheksdienstprogramm verwandeln, wie ich es in Java tun würde, aber ich vermute, dass es in Scala keine Notwendigkeit gibt)

Sie können verwenden

c map (t => t.getP -> t) toMap

Beachten Sie jedoch, dass dies 2 Durchquerungen erfordert.

Sie können eine Karte mit einer variablen Anzahl von Tupeln erstellen. Verwenden Sie also die Map-Methode für die Sammlung, um sie in eine Sammlung von Tupeln zu konvertieren, und verwenden Sie dann den Trick: _ *, um das Ergebnis in ein variables Argument zu konvertieren.

scala> val list = List("this", "maps", "string", "to", "length") map {s => (s, s.length)}
list: List[(java.lang.String, Int)] = List((this,4), (maps,4), (string,6), (to,2), (length,6))

scala> val list = List("this", "is", "a", "bunch", "of", "strings")
list: List[java.lang.String] = List(this, is, a, bunch, of, strings)

scala> val string2Length = Map(list map {s => (s, s.length)} : _*)
string2Length: scala.collection.immutable.Map[java.lang.String,Int] = Map(strings -> 7, of -> 2, bunch -> 5, a -> 1, is -> 2, this -> 4)

Zusätzlich zur Lösung von @James Iry ist dies auch mit einer Falte möglich. Ich vermute, dass diese Lösung etwas schneller ist als die Tupelmethode (es werden weniger Müllobjekte erstellt):

val list = List("this", "maps", "string", "to", "length")
val map = list.foldLeft(Map[String, Int]()) { (m, s) => m(s) = s.length }

Dies kann unveränderlich und mit einer einzigen Durchquerung implementiert werden, indem die Sammlung wie folgt gefaltet wird.

val map = c.foldLeft(Map[P, T]()) { (m, t) => m + (t.getP -> t) }

Die Lösung funktioniert, weil das Hinzufügen zu einer unveränderlichen Karte eine neue unveränderliche Karte mit dem zusätzlichen Eintrag zurückgibt und dieser Wert während der Faltoperation als Akkumulator dient.

Der Kompromiss hier ist die Einfachheit des Codes gegenüber seiner Effizienz. Für große Sammlungen ist dieser Ansatz möglicherweise besser geeignet als die Verwendung von zwei Durchquerungsimplementierungen, z. B. Anwenden von mapund toMap.

Eine andere Lösung (funktioniert möglicherweise nicht für alle Typen)

import scala.collection.breakOut
val m:Map[P, T] = c.map(t => (t.getP, t))(breakOut)

Dadurch wird die Erstellung der Zwischenliste vermieden. Weitere Informationen finden Sie hier: Scala 2.8 breakOut

Was Sie erreichen wollen, ist etwas undefiniert.
Was ist, wenn zwei oder mehr Elemente cdasselbe teilen p? Welches Element wird dem pin der Karte zugeordnet?

Die genauere Sichtweise besteht darin, eine Karte zwischen pund allen cElementen zu erstellen, die sie haben:

val m: Map[P, Collection[T]]

Dies könnte leicht mit groupBy erreicht werden :

val m: Map[P, Collection[T]] = c.groupBy(t => t.p)

Wenn Sie die ursprüngliche Karte weiterhin möchten, können Sie beispielsweise pdie erste Karte zuordnen , die tsie enthält:

val m: Map[P, T] = c.groupBy(t => t.p) map { case (p, ts) =>  p -> ts.head }

Dies ist wahrscheinlich nicht die effizienteste Methode, um eine Liste in eine Karte umzuwandeln, macht den aufrufenden Code jedoch besser lesbar. Ich habe implizite Konvertierungen verwendet, um List eine mapBy- Methode hinzuzufügen :

implicit def list2ListWithMapBy[T](list: List[T]): ListWithMapBy[T] = {
  new ListWithMapBy(list)
}

class ListWithMapBy[V](list: List[V]){
  def mapBy[K](keyFunc: V => K) = {
    list.map(a => keyFunc(a) -> a).toMap
  }
}

Beispiel für einen Aufrufcode:

val list = List("A", "AA", "AAA")
list.mapBy(_.length)                  //Map(1 -> A, 2 -> AA, 3 -> AAA)

Beachten Sie, dass der Aufrufercode aufgrund der impliziten Konvertierung die implicitConversions von scala importieren muss.

c map (_.getP) zip c

Funktioniert gut und ist sehr intuitiv

Wie wäre es mit zip und toMap?

myList.zip(myList.map(_.length)).toMap

Für das, was es wert ist, gibt es zwei sinnlose Möglichkeiten:

scala> case class Foo(bar: Int)
defined class Foo

scala> import scalaz._, Scalaz._
import scalaz._
import Scalaz._

scala> val c = Vector(Foo(9), Foo(11))
c: scala.collection.immutable.Vector[Foo] = Vector(Foo(9), Foo(11))

scala> c.map(((_: Foo).bar) &&& identity).toMap
res30: scala.collection.immutable.Map[Int,Foo] = Map(9 -> Foo(9), 11 -> Foo(11))

scala> c.map(((_: Foo).bar) >>= (Pair.apply[Int, Foo] _).curried).toMap
res31: scala.collection.immutable.Map[Int,Foo] = Map(9 -> Foo(9), 11 -> Foo(11))

Das funktioniert bei mir:

val personsMap = persons.foldLeft(scala.collection.mutable.Map[Int, PersonDTO]()) {
    (m, p) => m(p.id) = p; m
}

Die Karte muss veränderbar sein und die Karte muss zurückgegeben werden, da das Hinzufügen zu einer veränderlichen Karte keine Karte zurückgibt.

Verwenden Sie map () für die Sammlung, gefolgt von toMap

val map = list.map(e => (e, e.length)).toMap

Bei der Konvertierung von Json String (Lesen einer Json-Datei) in Scala Map

import spray.json._
import DefaultJsonProtocol._

val jsonStr = Source.fromFile(jsonFilePath).mkString
val jsonDoc=jsonStr.parseJson
val map_doc=jsonDoc.convertTo[Map[String, JsValue]]

// Get a Map key value
val key_value=map_doc.get("key").get.convertTo[String]

// If nested json, re-map it.
val key_map=map_doc.get("nested_key").get.convertTo[Map[String, JsValue]]
println("Nested Value " + key_map.get("key").get)