Scala meilleur moyen de transformer une Collection sur une Carte-par-clé?

Si j'ai une collection c de type T et il y a une propriété p sur T (de type P, par exemple), quel est le meilleur moyen de faire un la carte-par extraction-clés?

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'un mutable carte. Est-il une meilleure manière de faire ceci, de sorte que c'est en 1 ligne et je me retrouve avec un immuable Carte? (Évidemment, je pouvais tourner la ci-dessus en un simple bibliothèque de l'utilitaire, comme je le ferais en Java, mais je soupçonne que, dans la Scala, il n'est pas nécessaire)

InformationsquelleAutor oxbow_lakes | 2009-03-23

216

Vous pouvez utiliser
```
c map (t => t.getP -> t) toMap
```
mais sachez que ce besoin de 2 traversals.
- Je préfère encore mes suggestions dans le trac d'un Traversable[K].mapTo( K => V) et Traversable[V].mapBy( V => K) ont été mieux!
- Comme alternative, avec zip: c map (_.getP) zip c toMap
- Sachez que c'est une équation du second degré de l'opération, mais il en va de même pour la plupart des autres variantes donné ici. En regardant le code source de la scala.collection.mutable.MapBuilder etc, il me semble que pour chaque n-uplet, une nouvelle immuable carte est créée pour qui le tuple est ajouté.
- Sur ma machine pour une liste de 500 000 éléments, Scala code est environ 20 fois plus lent que le straight-forward Java approche (créer une table de hachage avec la taille appropriée, en boucle sur la liste de, mettre des éléments dans la carte). Pour 5 000 éléments, Scala ist environ 8 fois plus lent. La boucle approche écrit en Scala est à peu près 3 fois plus rapide que la toMap variante, mais encore entre 2 et 7 fois plus lent que Java.
- Veuillez s'il vous plaît fournir le test de sources à la communauté? Thx.
- Remplacer c avec c.iterator pour éviter la création de collecte intermédiaires.
- Avez-vous des résultats sur les performances avec Java 8 et les lambdas? 🙂
- Bonne question! Dans mon microbenchmarks, code avec ou sans les ruisseaux et les lamdas a exactement la même performance (dans mesurables de précision). L'initialisation de la carte avec la bonne taille (y compris facteur de charge!) rend le processus deux fois plus rapide dans chaque cas. La syntaxe à utiliser pour l'initialisation de la carte est un peu maladroit avec les ruisseaux. gist.github.com/jcsahnwaldt/f904de89a4440a1b0458
- Désolé, je ne trouve pas de sources plus.
- La suggestion avec tri ne fonctionne pas dans la version 2.10 (compilateur se plaint que Iterator[(P,T)] does not take parameters. Toutefois, les deux suggestions de travail en Scala 2.11.
InformationsquelleAutor Ben Lings
19

Vous pouvez construire une Carte avec un nombre variable de n-uplets. Il faut donc utiliser la méthode map sur la collection de le transformer en une collection de n-uplets et ensuite utiliser le : _* astuce pour convertir le résultat dans une variable d'argument.
```
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)
```
- J'ai lu à propos de Scala pour >2 semaines et de travail à travers des exemples et non pas une fois l'avais-je vu cela ": _ *" la notation! Merci beaucoup pour votre aide
- Juste pour mémoire, je me demande pourquoi nous avons besoin de préciser que c'est une séquence avec _. carte de convertir une liste de tuple ici. Alors, pourquoi l' _ ? Je veux dire, il fonctionne, mais je voudrais comprendre le type de nom ici
- Est-ce plus efficace que les autres méthodes?
InformationsquelleAutor James Iry
15

En plus de @James Iri de la solution, il est également possible de le faire à l'aide d'un pli. Je soupçonne que cette solution est un peu plus rapide que le n-uplet de la méthode (moins de déchets de la création d'objets):
```
val list = List("this", "maps", "string", "to", "length")
val map = list.foldLeft(Map[String, Int]()) { (m, s) => m(s) = s.length }
```
- Je vais essayer (je suis sûr que ça marche :-). Ce qui se passe avec l' "(m,s)=>m(s) = s.longueur de la" fonction? J'ai vu le typique foldLeft exemple avec une somme et une fonction "_ + _"; ce qui est beaucoup plus déroutant! La fonction semble supposer que j'ai déjà un n-uplet (m,s), dont je n'ai pas vraiment
- Est ce droit? Selon le scaladoc de foldLeft: "foldLeft [B](z : B)(op : (B, A) => B) : B" B dans ce cas, doit être une Carte[String, Int), donc je ne comprends pas vraiment la fonction dans votre exemple à tous! Elle doit retourner une Carte pour commencer, n'est-ce pas?
- OK - j'ai donc eu cette! "m(s) = s.longueur" (où m est une carte) retourne une nouvelle carte avec la cartographie "s -> s.longueur". Comment étais-je censé savoir cela? Je ne peux pas le trouver n'importe où dans la programmation scala sections sur les cartes!
- C'est-à scala du sucre syntaxique pour la mise à jour: Une affectation f(args) = e avec une fonction de demande à la gauche de l'opérateur '=' est interprété comme f.mise à jour(args, e), c'est à dire l'invocation d'une mise à jour de la fonction définie par f. [La Scala Langage De Spécification De La Version 2.7, 6.15 Assignments]
- L'homme, Scala était bizarre alors!
- Doit être mutables, non? Cela demande de mise à jour.
- J'ai essayer ton code, mais apparaissent d'erreur suivant: "la valeur de mise à jour n'est pas un membre de la scala.collection.immuable.Carte[String,Int]". Veuillez expliquer votre code de travail de ce code?
- n'a pas l'air de travailler.pour moi "l'Application ne prend pas de paramètres"
- C'est parce que pli gauche doit retourner une valeur après chaque itération ainsi. Cela devrait fonctionner. list.foldLeft(Map[String, Int]()) { (m, s) => m(s) = s.length; m } Également désolé pour 10 mois trop tard 🙂
- Immuable version: list.foldLeft(Map[String,Int]()) { (m,s) => m + (s -> s.length) }. Notez que si vous souhaitez utiliser la virgule pour construire le tuple, vous avez besoin d'une paire de parenthèses: ((s, s.length)).
InformationsquelleAutor Daniel Spiewak
9

Cela peut être mis en œuvre immuablement et avec une seule traversée par pliage à travers la collection comme suit.
```
val map = c.foldLeft(Map[P, T]()) { (m, t) => m + (t.getP -> t) }
```
La solution fonctionne parce que l'ajout d'un immuable la Carte renvoie une nouvelle immuable Carte avec l'entrée supplémentaire et cette valeur sert de l'accumulateur par le pli de l'opération.

La différence ici, c'est la simplicité du code par rapport à son efficacité. Donc, pour les grandes collections, cette approche peut être plus appropriée à l'aide de 2 traversée implémentations telles que l'application map et toMap.

InformationsquelleAutor RamV13
8

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 l'intermédiaire de la liste, plus d'info ici:
Scala 2.8 breakOut

InformationsquelleAutor Somatik
6

Ce que vous essayez d'atteindre est un peu indéfini.

Si deux ou plusieurs éléments dans c partagent le même p? L'article qui sera affecté à cette p dans la carte?

Le plus précis de façon de voir les choses est ce qui donne une carte entre p et tous les c éléments que l'ont:
```
val m: Map[P, Collection[T]]
```
Cela peut ê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, la carte p pour la première t qui a il:
```
val m: Map[P, T] = c.groupBy(t => t.p) map { case (p, ts) =>  p -> ts.head }
```
- D'un seul coup d'tweak sur cela est d'utiliser collect au lieu de map. Par exemple: c.group(t => t.p) collect { case (Some(p), ts) => p -> ts.head }. De cette façon, vous pouvez faire des choses comme aplatir les cartes lorsque vous entrez une Option[_].
- Bien sûr, cela pourrait être dit pour n'importe quelle carte. Ce n'est pas la question ici.
- Vous pouvez utiliser .mapValues(_.head) au lieu de la carte.
InformationsquelleAutor Eyal Roth

Ce n'est probablement pas le moyen le plus efficace pour transformer une liste de carte, mais il fait l'appel code plus lisible. J'ai utilisé des conversions implicites pour ajouter un mapBy méthode de la Liste:

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

Code appelant exemple:

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

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

InformationsquelleAutor Erez

2
```
c map (_.getP) zip c
```
Fonctionne bien et est très intuitiv
- S'il vous plaît ajouter plus de détails.
- Je suis désolé. Mais, c'EST une réponse à la question "Scala meilleur moyen de transformer une Collection sur une Carte-par-clé?" Ben Dépôts est.
- Et Ben n'a pas de fournir une explication?
- cela crée deux listes et de les combiner en une "carte" en utilisant les éléments dans c comme clé de tri (de). Remarque "à la carte", car la collection n'est pas un scala Map mais en crée une autre liste/itératif de tuples...mais l'effet est le même pour l'OP du but, je ne serait pas remise de la simplicité, mais il n'est pas aussi efficace que foldLeft solution, ni que c'est la vraie réponse à la question "à le transformer en une collection sur une carte-par-clé"
InformationsquelleAutor Jörg Bächtiger

Pour ce que ça vaut, ici, sont deux inutile façons 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))

Aussi, fwiw, c'est comment ces deux regarde dans Haskell: Map.fromList $ map (bar &&& id) c, Map.fromList $ map (bar >>= (,)) c.

InformationsquelleAutor missingfaktor

1

Comment sur l'utilisation de zip et toMap?
```
myList.zip(myList.map(_.length)).toMap
```
InformationsquelleAutor AwesomeBobX64
-1

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 de retour depuis l'ajout d'une mutable Carte ne prend pas en retour une carte.
- En fait, il peut être mis en œuvre immuablement comme suit: val personsMap = persons.foldLeft(Map[Int, PersonDTO]()) { (m, p) => m + (p.id -> p) } La Carte peut être immuable, comme démontré ci-dessus, car l'ajout d'une immuable la Carte renvoie une nouvelle immuable Carte avec l'entrée supplémentaire. Cette valeur sert de l'accumulateur par le pli de l'opération.
InformationsquelleAutor rustyfinger
-3

utilisation de la carte() sur la collecte de suivi avec toMap
```
val map = list.map(e => (e, e.length)).toMap
```
- Comment est-ce différent de la réponse qui lui a été soumis et accepté, il y a 7 ans?
InformationsquelleAutor Krishna Kumar Chourasiya

Vous devez vous connecter pour publier un commentaire.