Scala：如何合并地图集合

Question

我有一个 Map[String, Double] 列表，我想将它们的内容合并到一个 Map[String, Double] 中。 我应该如何以惯用的方式做到这一点？ 我想我应该能够通过折叠来做到这一点。 比如：

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

此外，我想以通用的方式处理按键冲突。 也就是说，如果我向已存在的映射添加一个键，我应该能够指定一个返回 Double 的函数（在本例中）并获取该键的现有值以及我要添加的值。 如果映射中尚不存在该键，则只需添加它并保持其值不变。

在我的具体情况下，我想构建一个 Map[String, Double] ，这样如果映射已经包含一个键，那么 Double 将被添加到现有的映射值中。

我正在我的特定代码中使用可变映射，但如果可能的话，我对更通用的解决方案感兴趣。

Answer 1

好吧，你可以这样做：

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
}

然后您可以通过 Pimp My Library 模式将此方法添加到映射类，并在原始示例中使用它而不是“++”：

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 在 2.7 中变为 keys，可能需要编写 filterKeys就filter和map而言，&变成了**，以此类推，不应该太不同了。

Answer 2

这个怎么样：

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 3

我很惊讶还没有人提出这个解决方案：

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 将元组列表转换为删除所有重复键的映射

Answer 4

从 Scala 2.13 开始，另一个处理重复键并且仅基于标准库的解决方案包括合并Map 在应用新的 groupMapReduce 运算符（顾名思义）相当于 groupBy ，后跟分组值的映射和归约步骤：

List(Map("hello" -> 1.1, "world" -> 2.2), Map("goodbye" -> 3.3, "hello" -> 4.4))
  .flatten
  .groupMapReduce(_._1)(_._2)(_ + _)
// Map("world" -> 2.2, "goodbye" -> 3.3, "hello" -> 5.5)

此：

• 展平s（连接）映射作为元组序列 (List(("hello", 1.1), ("world", 2.2), ("goodbye", 3.3), ("hello ", 4.4)))，它将所有键/值（甚至重复的键）保存

• group 元素基于其第一个元组部分 (_._1)（groupMapReduce 的组部分）

• map 将值分组到其第二个元组部分 (_._2)（组MapReduce 的映射部分）

• reduce 映射的分组值 ( _+_）通过求它们的总和（但它可以是任何reduce：（T，T）=> T 函数）（减少 groupMapReduce 的一部分）

---

groupMapReduce 步骤可以被视为 一次性版本相当于：

list.groupBy(_._1).mapValues(_.map(_._2).reduce(_ + _))

Answer 5

有趣的是，对此进行了一些思考，我得到了以下内容（在 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 之类的东西来说是可怕的。 另一个问题：在折叠内处理这个问题的更好方法是什么？

对于可变映射，这就是我在代码中处理的内容，并且通过一个不太通用的解决方案，我得到了这个：

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 6

我很快读了这个问题，所以我不确定我是否遗漏了一些东西（比如它必须适用于 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)

您可以更改 Double 的幺半群定义并获得另一种累积值的方法，在这里获取最大值：

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 7

我写了一篇关于此的博客文章，请查看：

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

基本上使用 scalaz semi group 你可以很容易地实现这一点，

看起来像：

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

Answer 8

一个 oneliner helper-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 9

def mergeMap[A, B](ms: List[Map[A, B]])(f: (B, B) => B): Map[A, B] = {
  ms.flatten.foldLeft(Map[A, B]()) { case (acc, (k, v)) =>
    acc + (if (acc.contains(k)) k -> f(acc(k), v) else (k, v))
  }
}