วิธีที่ดีที่สุดในการเปลี่ยนคอลเล็กชันให้เป็นแบบแผนที่โดยคีย์

หากฉันมีคอลเลกชัน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 traversals

คุณสามารถสร้างแผนที่ที่มีจำนวนตัวแปรอันดับ ดังนั้นใช้เมธอด map บนชุดสะสมเพื่อแปลงเป็นชุดของ tuples จากนั้นใช้เคล็ดลับ: _ * เพื่อแปลงผลลัพธ์ให้เป็นอาร์กิวเมนต์แบบแปรผัน

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 แล้วยังสามารถทำสิ่งนี้ได้โดยใช้การพับ ฉันสงสัยว่าโซลูชันนี้เร็วกว่าวิธี tuple เล็กน้อย (มีการสร้างวัตถุขยะน้อยลง):

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

วิธีแก้ปัญหาทำงานได้เนื่องจากการเพิ่มลงในแผนที่ที่ไม่เปลี่ยนรูปแบบจะส่งคืนแผนที่ที่ไม่เปลี่ยนรูปแบบใหม่ด้วยรายการเพิ่มเติมและค่านี้ทำหน้าที่เป็นตัวสะสมผ่านการดำเนินการพับ

ข้อเสียคือความเรียบง่ายของรหัสเมื่อเทียบกับประสิทธิภาพ ดังนั้นสำหรับคอลเลกชันขนาดใหญ่วิธีนี้อาจจะเหมาะกว่าการใช้ 2 การใช้งานข้ามเช่นการประยุกต์ใช้และmaptoMap

วิธีแก้ไขปัญหาอื่น (อาจใช้ไม่ได้กับทุกประเภท)

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)

โปรดทราบว่าเนื่องจากการแปลงโดยนัยรหัสผู้โทรต้องนำเข้า 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)