Scala najlepszy sposób przekształcania kolekcji w mapę po klawiszu?

Question

Jeśli mam kolekcję c typu T i nie jest własnością p na T (typu P, powiedzmy), co jest najlepszym sposobem, aby zrobić mapa po ekstrakcji-key?

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

Jednym ze sposobów jest następująca:

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

Ale teraz muszę zmienny mapę. Czy jest lepszy sposób na zrobienie tego, aby był w jednej linii, a kończy na niezmiennej niezmiennej Map? (Oczywiście mogłem zamienić powyższe w proste narzędzie biblioteki, tak jak w Javie, ale podejrzewam, że w Scali nie ma potrzeby)

Answer 1

Można użyć

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

ale należy pamiętać, że to wymaga przechodzenia między 2.

Answer 2

Można zbudować mapę ze zmienną liczbą krotek. Tak więc użyj metody map w kolekcji, aby przekształcić ją w kolekcję krotek, a następnie użyj: _ * trick, 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) 

Answer 3

Oprócz rozwiązania @James Iry, można to również zrobić za pomocą zakładki. Podejrzewam, że to rozwiązanie jest nieco szybciej niż metoda krotki (mniej obiekty są tworzone na śmieci):

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

Answer 4

Na co warto, tu są dwa bezsensowne sposoby robi:

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

Answer 5

Innym rozwiązaniem (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) 

to unika się tworzenia lista pośredników, więcej informacji tutaj: Scala 2.8 breakOut

Answer 6

To chyba nie jest najlepszy Np sposób, aby zmienić listę na mapę, ale sprawia, że ​​kod wywołujący jest bardziej czytelny. Kiedyś niejawne konwersje dodać mapBy metody 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 
    } 
} 

Wywołanie przykład kodu:

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

Należy pamiętać, że ze względu na niejawna konwersja, kod rozmówca musi importować implicitConversions Scala.

Answer 7

c map (_.getP) zip c 

działa dobrze i jest bardzo Intuitiv

Answer 8

Działa to dla mnie:

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

Mapa ma być zmienny i mapa musi być powrót ponieważ dodanie do zmienny mapa nie zwróć mapę.

Answer 9

To, co próbujesz osiągnąć, jest nieco nieokreślone.
Co się stanie, jeśli dwie lub więcej pozycji w c ma tę samą p? Który element zostanie przyporządkowany do tego p na mapie?

Im bardziej dokładny sposób patrzenia na ten przynosi mapę pomiędzy p i wszystkie c elementy, które go:

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

ten można łatwo osiągnąć groupBy:

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

Jeśli nadal chcesz oryginalnej mapy, możesz na przykład mapować p na pierwszą t, która ma:

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

Answer 10

Można to zaimplementować niezmiennie i jednym ruchem, składają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 mapą zwraca nowy niezmienny mapę z dodatkowym wejściem i wartość ta służy jako akumulator przez krotnym operacji.

Kompromisem tutaj jest prostota kodu, a jego efektywność. Tak więc w przypadku dużych kolekcji podejście to może być bardziej odpowiednie niż stosowanie dwóch implementacji, takich jak stosowanie map i toMap.

Answer 11

wykorzystanie map() w kolekcji, a następnie z toMap

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