Scala cara terbaik untuk mengubah Koleksi menjadi kunci-peta?

Jika saya memiliki koleksi ctipe Tdan ada properti pdi T(tipe P, katakanlah), apa cara terbaik untuk melakukan kunci peta-dengan-mengekstraksi ?

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

Salah satu caranya adalah sebagai berikut:

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

Tapi sekarang aku butuh peta yang bisa berubah . Apakah ada cara yang lebih baik untuk melakukan ini sehingga itu dalam 1 baris dan saya berakhir dengan Peta abadi ? (Jelas saya bisa mengubah hal di atas menjadi utilitas perpustakaan sederhana, seperti yang saya lakukan di Jawa, tetapi saya menduga bahwa di Scala tidak perlu)

Kamu bisa memakai

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

tapi ketahuilah bahwa ini membutuhkan 2 traversal.

Anda dapat membuat Peta dengan jumlah variabel tupel. Jadi gunakan metode peta pada koleksi untuk mengubahnya menjadi kumpulan tupel dan kemudian gunakan: _ * trik untuk mengubah hasilnya menjadi argumen variabel.

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)

Selain solusi @James Iry, Anda juga dapat melakukannya menggunakan lipatan. Saya menduga bahwa solusi ini sedikit lebih cepat daripada metode tuple (lebih sedikit objek sampah yang dibuat):

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

Ini dapat diimplementasikan secara kekal dan dengan satu traversal dengan melipat melalui koleksi sebagai berikut.

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

Solusinya bekerja karena menambahkan ke Peta yang tidak dapat diubah mengembalikan Peta yang tidak bisa diubah baru dengan entri tambahan dan nilai ini berfungsi sebagai akumulator melalui operasi lipat.

Yang menarik di sini adalah kesederhanaan kode versus efisiensinya. Jadi, untuk koleksi besar, pendekatan ini mungkin lebih cocok daripada menggunakan 2 implementasi traversal seperti menerapkan mapdan toMap.

Solusi lain (mungkin tidak bekerja untuk semua jenis)

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

ini menghindari pembuatan daftar perantara, info lebih lanjut di sini: Scala 2.8 breakOut

Apa yang ingin Anda capai sedikit tidak terdefinisi.
Bagaimana jika dua atau lebih item yang cdibagikan sama p? Item mana yang akan dipetakan dengan yang ada pdi peta?

Cara yang lebih akurat untuk melihat ini adalah menghasilkan peta antara pdan semua citem yang memilikinya:

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

Ini dapat dengan mudah dicapai dengan groupBy :

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

Jika Anda masih menginginkan peta asli, Anda dapat, misalnya, memetakan pke yang pertama tmemilikinya:

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

Ini mungkin bukan cara yang paling efisien untuk mengubah daftar menjadi peta, tetapi itu membuat kode panggilan lebih mudah dibaca. Saya menggunakan konversi implisit untuk menambahkan metode mapBy ke Daftar:

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

Contoh kode panggilan:

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

Perhatikan bahwa karena konversi implisit, kode pemanggil perlu mengimpor konversi implisit scala.

c map (_.getP) zip c

Bekerja dengan baik dan sangat intuitif

Bagaimana dengan menggunakan zip dan toMap?

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

Untuk apa nilainya, berikut adalah dua cara sia-sia melakukannya:

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

Ini bekerja untuk saya:

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

Peta harus bisa berubah dan Peta harus kembali karena menambahkan ke Peta yang bisa berubah tidak mengembalikan peta.

gunakan peta () pada koleksi diikuti dengan toMap

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

Jika mengkonversi dari Json String (membaca file json) ke 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)