¿Es la mejor forma de convertir una colección en un mapa por clave?

Si tengo una colección cde tipos Ty hay una propiedad pen T(de tipo P, por ejemplo), ¿cuál es la mejor manera de hacer una clave de mapa por extracción ?

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

Una forma es la siguiente:

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

Pero ahora necesito un mapa mutable . ¿Hay una mejor manera de hacer esto para que esté en 1 línea y termine con un Mapa inmutable ? (Obviamente, podría convertir lo anterior en una simple utilidad de biblioteca, como lo haría en Java, pero sospecho que en Scala no hay necesidad)

Puedes usar

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

pero tenga en cuenta que esto necesita 2 recorridos.

Puede construir un mapa con un número variable de tuplas. Por lo tanto, use el método de mapa en la colección para convertirlo en una colección de tuplas y luego use el truco: _ * para convertir el resultado en un argumento 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)

Además de la solución de @James Iry, también es posible lograr esto usando un pliegue. Sospecho que esta solución es un poco más rápida que el método de tupla (se crean menos objetos basura):

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

Esto se puede implementar de manera inmutable y con un solo recorrido al plegar la colección de la siguiente manera.

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

La solución funciona porque agregar a un Mapa inmutable devuelve un nuevo Mapa inmutable con la entrada adicional y este valor sirve como acumulador a través de la operación de plegado.

La desventaja aquí es la simplicidad del código versus su eficiencia. Por lo tanto, para colecciones grandes, este enfoque puede ser más adecuado que usar 2 implementaciones transversales como la aplicación mapy toMap.

Otra solución (puede que no funcione para todos los tipos)

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

esto evita la creación de la lista de intermediarios, más información aquí: Scala 2.8 breakOut

Lo que estás tratando de lograr es un poco indefinido.
¿Qué pasa si dos o más elementos ccomparten lo mismo p? ¿Qué elemento se asignará a eso pen el mapa?

La forma más precisa de ver esto es generar un mapa entre py todos los celementos que lo tienen:

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

Esto podría lograrse fácilmente con groupBy :

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

Si aún desea el mapa original, puede, por ejemplo, asignar pal primero tque lo tiene:

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

Probablemente esta no sea la forma más eficiente de convertir una lista en un mapa, pero hace que el código de llamada sea más legible. Usé conversiones implícitas para agregar un método mapBy a 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
  }
}

Ejemplo de código de llamada:

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

Tenga en cuenta que debido a la conversión implícita, el código de la persona que llama necesita importar las conversiones implícitas de scala.

c map (_.getP) zip c

Funciona bien y es muy intuitivo.

¿Qué tal usar zip y toMap?

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

Por lo que vale, aquí hay dos formas inútiles de hacerlo:

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

Esto funciona para mi:

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

El mapa debe ser mutable y el mapa debe ser devuelto ya que agregarlo a un mapa mutable no devuelve un mapa.

use map () en la colección seguido de toMap

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

Si se convierte de Json String (leyendo un archivo json) a 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)