Il modo migliore di Scala di trasformare una collezione in una mappa per chiave?

Se ho una raccolta cdi tipi Te c'è una proprietà psu T(di tipo P, diciamo), qual è il modo migliore per fare una mappa per estrazione-chiave ?

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

Un modo è il seguente:

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

Ma ora ho bisogno di una mappa mutabile . C'è un modo migliore per farlo in modo che sia in 1 riga e finisca con una mappa immutabile ? (Ovviamente potrei trasformare quanto sopra in una semplice utility di libreria, come farei in Java, ma sospetto che a Scala non sia necessario)

Puoi usare

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

ma tieni presente che ciò richiede 2 traversate.

Puoi costruire una mappa con un numero variabile di tuple. Quindi usa il metodo map sulla raccolta per convertirlo in una raccolta di tuple e quindi usa il trucco: _ * per convertire il risultato in un argomento variabile.

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)

Oltre alla soluzione @James Iry, è anche possibile farlo usando una piega. Sospetto che questa soluzione sia leggermente più veloce del metodo tupla (vengono creati meno oggetti spazzatura):

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

Questo può essere implementato immutabilmente e con un unico attraversamento piegando la collezione come segue.

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

La soluzione funziona perché l'aggiunta a una mappa immutabile restituisce una nuova mappa immutabile con la voce aggiuntiva e questo valore funge da accumulatore durante l'operazione di piegatura.

Il compromesso qui è la semplicità del codice rispetto alla sua efficienza. Pertanto, per le raccolte di grandi dimensioni, questo approccio può essere più adatto rispetto all'utilizzo di 2 implementazioni trasversali come application mape toMap.

Un'altra soluzione (potrebbe non funzionare per tutti i tipi)

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

questo evita la creazione dell'elenco degli intermediari, maggiori informazioni qui: Scala 2.8 breakOut

Quello che stai cercando di ottenere è un po 'indefinito.
Cosa succede se due o più articoli in ccondividono lo stesso p? Quale elemento verrà mappato a quello pnella mappa?

Il modo più accurato di guardare a questo è produrre una mappa tra pe tutti gli celementi che la possiedono:

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

Questo potrebbe essere facilmente raggiunto con groupBy :

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

Se vuoi ancora la mappa originale, puoi, ad esempio, mappare palla prima tche l'ha:

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

Questo probabilmente non è il modo più efficiente per trasformare un elenco in mappa, ma rende più leggibile il codice chiamante. Ho usato conversioni implicite per aggiungere un metodo mapBy all'elenco:

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

Esempio di codice chiamante:

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

Si noti che a causa della conversione implicita, il codice chiamante deve importare le implicitConversions di Scala.

c map (_.getP) zip c

Funziona bene ed è molto intuitivo

Che ne dici di usare zip e toMap?

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

Per quello che vale, ecco due modi inutili per farlo:

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

Questo funziona per me:

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

La mappa deve essere modificabile e la mappa deve essere restituita poiché l'aggiunta a una mappa mutabile non restituisce una mappa.

usa map () sulla collezione seguito da toMap

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

Se si converte da Json String (leggendo un file json) 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)