Scala лучший способ превратить коллекцию в карту под ключ?

Если у меня есть коллекция cтипа Tи есть свойство pна T(типа P, скажем), что это лучший способ , чтобы сделать карту-на-экстрагента-ключ ?

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

Одним из способов является следующее:

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

Но сейчас мне нужна изменчивая карта. Есть ли лучший способ сделать это так, чтобы он был в 1 строке, и я получил неизменную карту? (Очевидно, я мог бы превратить вышесказанное в простую библиотечную утилиту, как в Java, но я подозреваю, что в Scala нет необходимости)

Ты можешь использовать

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

но имейте в виду, что для этого нужно 2 обхода.

Вы можете создать карту с переменным количеством кортежей. Поэтому используйте метод map в коллекции, чтобы преобразовать его в коллекцию кортежей, а затем используйте трюк: _ *, чтобы преобразовать результат в переменный аргумент.

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)

В дополнение к решению @James Iry, это также можно сделать с помощью сгиба. Я подозреваю, что это решение немного быстрее, чем метод кортежа (создается меньше мусорных объектов):

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

Это может быть реализовано в неизменном виде и за один проход путем складывания коллекции следующим образом.

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

Решение работает, потому что добавление в неизменяемую Карту возвращает новую неизменяемую Карту с дополнительной записью, и это значение служит аккумулятором при операции сгиба.

Компромисс здесь - простота кода и его эффективность. Таким образом, для больших коллекций этот подход может быть более подходящим, чем использование двух реализаций обхода, таких как применение mapи toMap.

Другое решение (может не работать для всех типов)

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

это позволяет избежать создания списка посредников, более подробная информация здесь: Scala 2.8 breakOut

То, что вы пытаетесь достичь, немного неопределенно.
Что делать, если два или более элементов в cодной и той же p? Какой элемент будет сопоставлен с этим pна карте?

Более точный способ взглянуть на это - получить карту между pвсеми cпредметами, имеющими ее:

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

Это может быть легко достигнуто с groupBy :

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

Если вы все еще хотите исходную карту, вы можете, например, сопоставить pс первой, tкоторая имеет ее:

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

Вероятно, это не самый эффективный способ преобразования списка в карту, но он делает код вызова более читабельным. Я использовал неявные преобразования, чтобы добавить метод mapBy в 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
  }
}

Пример телефонного кода:

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

Обратите внимание, что из-за неявного преобразования код вызывающей стороны должен импортировать implicitConversions в scala.

c map (_.getP) zip c

Работает хорошо и очень интуитивно

Как насчет использования zip и toMap?

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

Для чего это стоит, вот два бессмысленных способа сделать это:

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

Это работает для меня:

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

Карта должна быть изменяемой, а Карта должна быть возвращена, поскольку добавление в изменяемую Карту не возвращает карту.

использовать map () для коллекции с последующей toMap

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

При преобразовании из Json String (чтение файла JSON) в 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)