Найкращий спосіб 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) }

Але зараз мені потрібна змінна карта. Чи є кращий спосіб зробити це, щоб воно було в одному рядку, і я закінчував незмінну карту? (Очевидно, я міг би перетворити вищезазначене на просту утиліту бібліотеки, як у 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 до списку:

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)

Зауважте, що через неявну конверсію код абонента повинен імпортувати неявні конверсії 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
}

Карта має бути зміненою, а карту потрібно повернути, оскільки додавання до змінної карти не повертає карту.

використовувати карту () для колекції, а потім - toMap

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

Якщо переходить з Json String (читання файлу json) в масштабовану карту

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)