Scala est le meilleur moyen de transformer une collection en une carte par clé?

Si j'ai une collection cde type Tet qu'il y a une propriété psur T(de type P, par exemple), quelle est la meilleure façon de faire une carte par clé d'extraction ?

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

Une façon est la suivante:

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

Mais maintenant, j'ai besoin d'une carte mutable . Y a-t-il une meilleure façon de faire cela pour que ce soit sur 1 ligne et que je me retrouve avec une carte immuable ? (Évidemment, je pourrais transformer ce qui précède en un simple utilitaire de bibliothèque, comme je le ferais en Java, mais je soupçonne que dans Scala, ce n'est pas nécessaire)

Vous pouvez utiliser

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

mais sachez que cela nécessite 2 traversées.

Vous pouvez construire une carte avec un nombre variable de tuples. Utilisez donc la méthode map sur la collection pour la convertir en une collection de tuples, puis utilisez l'astuce: _ * pour convertir le résultat en argument variable.

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)

En plus de la solution de @James Iry, il est également possible d'accomplir cela en utilisant un pli. Je soupçonne que cette solution est légèrement plus rapide que la méthode tuple (moins d'objets garbage sont créés):

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

Cela peut être implémenté de manière immuable et avec un seul parcours en repliant la collection comme suit.

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

La solution fonctionne car l'ajout à une carte immuable retourne une nouvelle carte immuable avec l'entrée supplémentaire et cette valeur sert d'accumulateur via l'opération de repli.

Le compromis ici est la simplicité du code par rapport à son efficacité. Ainsi, pour les grandes collections, cette approche peut être plus appropriée que l'utilisation de 2 implémentations de traversée telles que l'application mapet toMap.

Une autre solution (peut ne pas fonctionner pour tous les types)

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

cela évite la création de la liste intermédiaire, plus d'infos ici: Scala 2.8 breakOut

Ce que vous essayez d'atteindre est un peu indéfini.
Que faire si deux ou plusieurs éléments cpartagent le même p? Quel élément sera mappé à celui pde la carte?

La façon la plus précise de voir cela est de produire une carte entre pet tous les céléments qui la contiennent:

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

Cela pourrait être facilement réalisé avec groupBy :

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

Si vous voulez toujours la carte d'origine, vous pouvez, par exemple, mapper psur la première tqui la possède:

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

Ce n'est probablement pas le moyen le plus efficace de transformer une liste en carte, mais cela rend le code d'appel plus lisible. J'ai utilisé des conversions implicites pour ajouter une méthode mapBy à List:

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

Exemple de code d'appel:

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

Notez qu'en raison de la conversion implicite, le code de l'appelant doit importer implicitConversions de scala.

c map (_.getP) zip c

Fonctionne bien et est très intuitif

Que diriez-vous d'utiliser zip et toMap?

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

Pour ce que ça vaut, voici deux façons inutiles de le faire:

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

Cela fonctionne pour moi:

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

La carte doit être mutable et la carte doit être retournée car l'ajout à une carte mutable ne renvoie pas de carte.

utiliser map () sur la collection suivi de toMap

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

En cas de conversion de Json String (lecture d'un fichier json) en 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)