Scala cách tốt nhất để biến Bộ sưu tập thành Bản đồ chính?

Nếu tôi có một bộ sưu tập cloại Tvà có một thuộc tính ptrên T(loại P, giả sử), cách tốt nhất để thực hiện khóa bản đồ là gì?

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

Một cách là như sau:

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

Nhưng bây giờ tôi cần một bản đồ có thể thay đổi . Có cách nào tốt hơn để làm điều này sao cho nó thành 1 dòng và tôi kết thúc với một Bản đồ bất biến ? (Rõ ràng tôi có thể biến phần trên thành một tiện ích thư viện đơn giản, như tôi có trong Java, nhưng tôi nghi ngờ rằng trong Scala không có nhu cầu)

Bạn có thể dùng

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

nhưng lưu ý rằng điều này cần 2 điểm.

Bạn có thể xây dựng một Bản đồ với số lượng bộ dữ liệu thay đổi. Vì vậy, sử dụng phương pháp bản đồ trên bộ sưu tập để chuyển đổi nó thành một bộ sưu tập các bộ dữ liệu và sau đó sử dụng mẹo: _ * để chuyển đổi kết quả thành một đối số biến.

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)

Ngoài giải pháp của @James Iry, bạn cũng có thể thực hiện việc này bằng cách sử dụng một lần. Tôi nghi ngờ rằng giải pháp này nhanh hơn một chút so với phương pháp tuple (tạo ra ít đối tượng rác hơn):

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

Điều này có thể được thực hiện một cách bất biến và với một lần di chuyển bằng cách gấp qua bộ sưu tập như sau.

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

Giải pháp hoạt động vì thêm vào Bản đồ bất biến sẽ trả về Bản đồ bất biến mới với mục nhập bổ sung và giá trị này đóng vai trò là bộ tích lũy thông qua thao tác gấp.

Sự đánh đổi ở đây là sự đơn giản của mã so với hiệu quả của nó. Vì vậy, đối với các bộ sưu tập lớn, cách tiếp cận này có thể phù hợp hơn so với sử dụng 2 triển khai truyền tải như áp dụng mapvà toMap.

Một giải pháp khác (có thể không hoạt động cho tất cả các loại)

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

điều này tránh việc tạo danh sách trung gian, thông tin thêm ở đây: Scala 2.8 breakOut

Những gì bạn đang cố gắng để đạt được là một chút không xác định.
Điều gì nếu hai hoặc nhiều mục trong ccùng một p? Mục nào sẽ được ánh xạ tới đó ptrong bản đồ?

Cách chính xác hơn để xem xét điều này là thu được một bản đồ giữa pvà tất cả ccác mục có nó:

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

Điều này có thể dễ dàng đạt được với groupBy :

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

Nếu bạn vẫn muốn bản đồ gốc, ví dụ, bạn có thể ánh xạ ptới bản đồ đầu tiên tcó bản đồ đó:

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

Đây có lẽ không phải là cách hiệu quả nhất để biến danh sách thành bản đồ, nhưng nó làm cho mã cuộc gọi dễ đọc hơn. Tôi đã sử dụng chuyển đổi ngầm để thêm phương thức mapBy vào Danh sách:

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

Ví dụ mã gọi:

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

Lưu ý rằng do chuyển đổi ngầm định, mã người gọi cần nhập ẩn ẩn của Scala.

c map (_.getP) zip c

Hoạt động tốt và rất trực quan

Làm thế nào về việc sử dụng zip và toMap?

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

Đối với những gì nó có giá trị, đây là hai cách làm vô nghĩa :

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

Điều này làm việc cho tôi:

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

Bản đồ phải có thể thay đổi và Bản đồ phải được trả lại do việc thêm vào Bản đồ có thể thay đổi sẽ không trả lại bản đồ.

sử dụng map () trên bộ sưu tập theo sau với toMap

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

Nếu chuyển đổi từ Chuỗi Json (đọc tệp json) sang 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)