La meilleure façon en Scala de transformer une Collection en une Map-by-key ?

Question

Si j'ai une collection c de type T et il y a une propriété p sur T (de type P ), quelle est la meilleure manière de faire un carte par clé d'extraction ?

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

L'un des moyens est le suivant :

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

Mais maintenant j'ai besoin d'un mutable carte. Existe-t-il une meilleure façon de procéder pour que tout se passe sur une seule ligne et que je me retrouve avec une carte de type immuable Carte ? (Je pourrais évidemment transformer ce qui précède en un simple utilitaire de bibliothèque, comme je le ferais en Java, mais je pense qu'en Scala, ce n'est pas nécessaire).

Answer 1

Vous pouvez utiliser

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

mais attention, cela nécessite 2 traversées.

Answer 2

Vous pouvez construire une Map 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 un 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)

Answer 3

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

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

Answer 4

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 permet d'éviter la création de la liste intermédiaire, plus d'infos ici : Scala 2.8 breakOut

Answer 5

Pour ce que ça vaut, en voici deux inutile des moyens 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))