Jaki jest najlepszy sposób na przekształcenie kolekcji w mapę według klucza?

Jeśli mam kolekcję ctypu Ti nie ma właściwość pna T(typu P, powiedzmy), co jest najlepszym sposobem, aby zrobić MAP-by-wydobycia kluczu ?

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

Jeden sposób jest następujący:

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

Ale teraz potrzebuję mutowalnej mapy. Czy jest lepszy sposób na zrobienie tego, aby było to w jednej linii, a ja otrzymałem niezmienną mapę? (Oczywiście mógłbym zamienić powyższe w proste narzędzie biblioteczne, tak jak zrobiłbym to w Javie, ale podejrzewam, że w Scali nie ma takiej potrzeby)

Możesz użyć

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

ale pamiętaj, że wymaga to 2 przejść.

Możesz skonstruować Mapę ze zmienną liczbą krotek. Więc użyj metody map na kolekcji, aby przekonwertować ją na kolekcję krotek, a następnie użyj sztuczki: _ *, aby przekonwertować wynik na zmienny 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)

Oprócz rozwiązania @James Iry można to również osiągnąć za pomocą fałdy. Podejrzewam, że to rozwiązanie jest nieco szybsze niż metoda krotki (powstaje mniej śmieci):

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

Można to zaimplementować niezmiennie i za pomocą pojedynczego przejścia, zwijając kolekcję w następujący sposób.

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

Rozwiązanie działa, ponieważ dodanie do niezmiennej mapy zwraca nową niezmienną mapę z dodatkowym wpisem, a ta wartość służy jako akumulator podczas operacji fold.

Kompromisem jest tutaj prostota kodu w porównaniu z jego wydajnością. Dlatego w przypadku dużych kolekcji to podejście może być bardziej odpowiednie niż użycie 2 implementacji przechodzenia, takich jak stosowanie mapi toMap.

Inne rozwiązanie (może nie działać dla wszystkich typów)

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

pozwala to uniknąć tworzenia listy pośredników, więcej informacji tutaj: Scala 2.8 breakOut

To, co próbujesz osiągnąć, jest nieco nieokreślone.
Co się stanie, jeśli co najmniej dwa elementy csą takie same p? Który element zostanie zmapowany do tego pna mapie?

Bardziej dokładnym sposobem spojrzenia na to jest przedstawienie mapy między pwszystkimi cprzedmiotami, które ją zawierają:

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

Można to łatwo osiągnąć dzięki groupBy :

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

Jeśli nadal potrzebujesz oryginalnej mapy, możesz na przykład zmapować pją na pierwszą t, która ją ma:

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

Prawdopodobnie nie jest to najskuteczniejszy sposób przekształcenia listy w mapę, ale sprawia, że ​​kod wywołujący jest bardziej czytelny. Użyłem niejawnych konwersji, aby dodać metodę mapBy do listy:

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

Przykład kodu telefonicznego:

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

Należy zauważyć, że z powodu niejawnej konwersji kod wywołujący musi zaimportować implicitConversions scali.

c map (_.getP) zip c

Działa dobrze i jest bardzo intuicyjny

A co powiesz na używanie zip i toMap?

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

Oto dwa bezsensowne sposoby na zrobienie tego:

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

To działa dla mnie:

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

Mapa musi być zmienna, a mapa musi zostać zwrócona, ponieważ dodanie do mapy zmiennej nie zwraca mapy.

użyj map () na kolekcji, a następnie toMap

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

W przypadku konwersji z Json String (odczyt pliku json) do 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)