Scala, bir koleksiyonu anahtar haritaya dönüştürmenin en iyi yolu mu?

Bir ctür koleksiyonum varsa Tve (tür , örneğin) püzerinde bir özellik varsa, bir eşleme anahtarı ile yapmanın en iyi yolu nedir?TP

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

Bunun bir yolu şudur:

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

Ama şimdi değişebilir bir haritaya ihtiyacım var . O 1 doğrultusunda ve ben bir ile bitirmek böylece bunu yapmanın daha iyi bir yolu var mı değişmez Haritası? (Açıkçası yukarıdakileri Java'da olduğu gibi basit bir kütüphane yardımcı programına dönüştürebilirim, ancak Scala'da gerek olmadığından şüpheleniyorum)

Kullanabilirsiniz

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

ancak bunun 2 geçişe ihtiyaç duyduğunu unutmayın.

Değişken sayıda tuple içeren bir Harita oluşturabilirsiniz. Bu yüzden koleksiyondaki map yöntemini kullanarak bir tuples koleksiyonuna dönüştürün ve ardından sonucu değişken bir argümana dönüştürmek için: _ * hile kullanı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)

@James Iry'nin çözümüne ek olarak, bunu bir katlama kullanarak da yapmak mümkündür. Bu çözüm tuple yönteminden biraz daha hızlı olduğundan şüpheleniyorum (daha az çöp nesnesi oluşturulur):

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

Bu, derlemeden ve katlama yoluyla aşağıdaki gibi katlanarak tek bir geçişle uygulanabilir.

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

Çözüm, değişmez bir Haritaya eklemek, ek giriş ile yeni bir değişmez Harita döndürdüğü ve bu değerin katlama işlemi boyunca akümülatör görevi görmesi nedeniyle çalışır.

Buradaki takas, kodun verimliliğine karşı sadeliğidir. Bu nedenle, büyük koleksiyonlar için, bu yaklaşım mapve gibi 2 çapraz uygulama kullanmaktan daha uygun olabilir toMap.

Başka bir çözüm (tüm türler için çalışmayabilir)

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

bu, aracı listesinin oluşturulmasını önler, daha fazla bilgi burada: Scala 2.8 breakOut

Ulaşmaya çalıştığınız şey biraz tanımsız.
Ya iki veya daha fazla öğe cpaylaşıyorsa p? pHaritada hangi öğe eşlenecek ?

Buna bakmanın en doğru yolu, sahip olduğu ptüm cöğeler arasında bir harita sunmaktır :

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

Bu, groupBy ile kolayca gerçekleştirilebilir :

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

Yine de orijinal haritayı istiyorsanız, örneğin, ona sahip polan ilk haritayı eşleyebilirsiniz t:

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

Bu, bir listeyi eşleştirmek için en etkili yol değildir, ancak arama kodunu daha okunabilir hale getirir. Listeye bir mapBy yöntemi eklemek için örtük dönüşümler kullandım :

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

Telefon kodu örneği:

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

Örtük dönüşüm nedeniyle, arayan kodunun scala'nın implicitConversions dosyasını içe aktarması gerektiğini unutmayın.

c map (_.getP) zip c

İyi çalışıyor ve çok sezgisel

Zip ve toMap kullanmaya ne dersiniz?

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

Değeri için, işte bunu yapmanın iki anlamsız yolu:

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

Bu benim için çalışıyor:

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

Değiştirilebilir bir Haritaya ekleme bir harita döndürmediği için Harita değiştirilebilir ve Harita geri döndürülmelidir.

Koleksiyonda map () kullanın ve ardından toMap kullanın

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

Json String'ten (json dosyasını okuma) scala Map'e dönüştürüyorsanız

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)