Scala：如何合併地圖集合

Question

我有一個Map [String，Double]列表，我想將它們的內容合併到一個Map [String，Double]中。我應該如何用慣用的方式來做到這一點？我想我應該能夠做到這一點。類似於：

val newMap = Map[String, Double]() /: listOfMaps { (accumulator, m) => ... } 

此外，我想以通用方式處理關鍵衝突。也就是說，如果我將一個鍵添加到已存在的映射中，我應該能夠指定一個返回Double的函數（在這種情況下），並將該鍵的現有值加上我試圖添加的值。如果密鑰尚未存在於地圖中，則只需添加它，並且其值不變。

在我的具體情況下，我想建立一個Map [String，Double]，如果地圖已經包含一個鍵，那麼Double將被添加到現有的地圖值。

我正在使用特定代碼中的可變映射，但如果可能的話，我對更通用的解決方案感興趣。

Answer 1

這個怎麼樣：

def mergeMap[A, B](ms: List[Map[A, B]])(f: (B, B) => B): Map[A, B] = 
    (Map[A, B]() /: (for (m <- ms; kv <- m) yield kv)) { (a, kv) => 
    a + (if (a.contains(kv._1)) kv._1 -> f(a(kv._1), kv._2) else kv) 
    } 

val ms = List(Map("hello" -> 1.1, "world" -> 2.2), Map("goodbye" -> 3.3, "hello" -> 4.4)) 
val mm = mergeMap(ms)((v1, v2) => v1 + v2) 

println(mm) // prints Map(hello -> 5.5, world -> 2.2, goodbye -> 3.3) 

而且這兩個2.7.5和2.8.0的作品。

Answer 2

嗯，你可以這樣做：

mapList reduce (_ ++ _) 

除了碰撞的特殊要求。

既然你有特殊的要求，也許最好的是做這樣的事情（2.8）：

def combine(m1: Map, m2: Map): Map = { 
    val k1 = Set(m1.keysIterator.toList: _*) 
    val k2 = Set(m2.keysIterator.toList: _*) 
    val intersection = k1 & k2 

    val r1 = for(key <- intersection) yield (key -> (m1(key) + m2(key))) 
    val r2 = m1.filterKeys(!intersection.contains(_)) ++ m2.filterKeys(!intersection.contains(_)) 
    r2 ++ r1 
} 

可以，則此方法通過皮條客我的圖書館模式添加到地圖類，並使用它在原來的例子，而不是「++」：

class CombiningMap(m1: Map[Symbol, Double]) { 
    def combine(m2: Map[Symbol, Double]) = { 
    val k1 = Set(m1.keysIterator.toList: _*) 
    val k2 = Set(m2.keysIterator.toList: _*) 
    val intersection = k1 & k2 
    val r1 = for(key <- intersection) yield (key -> (m1(key) + m2(key))) 
    val r2 = m1.filterKeys(!intersection.contains(_)) ++ m2.filterKeys(!intersection.contains(_)) 
    r2 ++ r1 
    } 
} 

// Then use this: 
implicit def toCombining(m: Map[Symbol, Double]) = new CombiningMap(m) 

// And finish with: 
mapList reduce (_ combine _) 

雖然這是寫在2.8，所以keysIterator成爲keys 2.7，filterKeys可能需要在方面來寫和map,&變成**等等，它不應該太差。

Answer 3

有趣的是，這個有點繞noodling，我得到了以下（上2.7.5）：

一般地圖：

def mergeMaps[A,B](collisionFunc: (B,B) => B)(listOfMaps: Seq[scala.collection.Map[A,B]]): Map[A, B] = { 
    listOfMaps.foldLeft(Map[A, B]()) { (m, s) => 
     Map(
     s.projection.map { pair => 
     if (m contains pair._1) 
      (pair._1, collisionFunc(m(pair._1), pair._2)) 
     else 
      pair 
     }.force.toList:_*) 
    } 
    } 

但是男人，那是可怕的與投影和強迫和toList和whatnot。另外一個問題：在這個範圍內處理這個問題的最好方法是什麼？

對於易變的地圖，這是我在我的代碼處理，並用較少的通用的解決方案，我得到這個：

def mergeMaps[A,B](collisionFunc: (B,B) => B)(listOfMaps: List[mutable.Map[A,B]]): mutable.Map[A, B] = { 
    listOfMaps.foldLeft(mutable.Map[A,B]()) { 
     (m, s) => 
     for (k <- s.keys) { 
     if (m contains k) 
      m(k) = collisionFunc(m(k), s(k)) 
     else 
      m(k) = s(k) 
     } 
     m 
    } 
    } 

這似乎有點清潔，但只會用可變工作寫入地圖。有趣的是，我首先使用/來代替foldLeft嘗試上面的（在我問這個問題之前），但是我得到了類型錯誤。我認爲/：和foldLeft基本上是等價的，但編譯器不停地抱怨我需要明確的類型（m，s）。那是怎麼回事？

Answer 4

我趕緊閱讀這個問題，所以我不知道如果我失去了一些東西（像它爲2.7.x或沒有scalaz工作）：

import scalaz._ 
import Scalaz._ 
val ms = List(Map("hello" -> 1.1, "world" -> 2.2), Map("goodbye" -> 3.3, "hello" -> 4.4)) 
ms.reduceLeft(_ |+| _) 
// returns Map(goodbye -> 3.3, hello -> 5.5, world -> 2.2) 

您可以更改獨異的定義雙並獲得另一種方式來累積值，及彼最大：

implicit val dbsg: Semigroup[Double] = semigroup((a,b) => math.max(a,b)) 
ms.reduceLeft(_ |+| _) 
// returns Map(goodbye -> 3.3, hello -> 4.4, world -> 2.2) 

Answer 5

一個oneliner幫手，FUNC，其使用讀取幾乎一樣使用scalaz清潔：

def mergeMaps[K,V](m1: Map[K,V], m2: Map[K,V])(f: (V,V) => V): Map[K,V] = 
    (m1 -- m2.keySet) ++ (m2 -- m1.keySet) ++ (for (k <- m1.keySet & m2.keySet) yield { k -> f(m1(k), m2(k)) }) 

val ms = List(Map("hello" -> 1.1, "world" -> 2.2), Map("goodbye" -> 3.3, "hello" -> 4.4)) 
ms.reduceLeft(mergeMaps(_,_)(_ + _)) 
// returns Map(goodbye -> 3.3, hello -> 5.5, world -> 2.2) 

爲最終可讀性包裝在一個隱含的定製類型：

class MyMap[K,V](m1: Map[K,V]) { 
    def merge(m2: Map[K,V])(f: (V,V) => V) = 
    (m1 -- m2.keySet) ++ (m2 -- m1.keySet) ++ (for (k <- m1.keySet & m2.keySet) yield { k -> f(m1(k), m2(k)) }) 
} 
implicit def toMyMap[K,V](m: Map[K,V]) = new MyMap(m) 

val ms = List(Map("hello" -> 1.1, "world" -> 2.2), Map("goodbye" -> 3.3, "hello" -> 4.4)) 
ms reduceLeft { _.merge(_)(_ + _) } 

Answer 6

我寫了一篇博客文章中針對此，檢查出來：

http://www.nimrodstech.com/scala-map-merge/

基本上都採用scalaz半組可以實現這很容易

看起來像這樣：

import scalaz.Scalaz._ 
    listOfMaps reduce(_ |+| _) 

Answer 7

我很驚訝，沒有人想出這個解決方案尚未：

myListOfMaps.flatten.toMap 

不正是你所需要的：

1. 融合了列表中單個地圖
2. 雜草出任何重複鑰匙

例如：

scala> List(Map('a -> 1), Map('b -> 2), Map('c -> 3), Map('a -> 4, 'b -> 5)).flatten.toMap 
res7: scala.collection.immutable.Map[Symbol,Int] = Map('a -> 4, 'b -> 5, 'c -> 3) 

flatten打開的地圖列表成元組的平面列表，toMap輪流元組的名單與所有的重複鍵的地圖取出