合并两个映射并求和相同键的值的最佳方法？

val map1 = Map(1 -> 9 , 2 -> 20)
val map2 = Map(1 -> 100, 3 -> 300)

我想合并它们，并对相同键的值求和。因此结果将是：

Map(2->20, 1->109, 3->300)

现在我有2个解决方案：

val list = map1.toList ++ map2.toList
val merged = list.groupBy ( _._1) .map { case (k,v) => k -> v.map(_._2).sum }

和

val merged = (map1 /: map2) { case (map, (k,v)) =>
    map + ( k -> (v + map.getOrElse(k, 0)) )
}

但是我想知道是否有更好的解决方案。

Scalaz有一个概念半群什么你想在这里做的捕获，并导致无疑是最短/干净的解决方案：

scala> import scalaz._
import scalaz._

scala> import Scalaz._
import Scalaz._

scala> val map1 = Map(1 -> 9 , 2 -> 20)
map1: scala.collection.immutable.Map[Int,Int] = Map(1 -> 9, 2 -> 20)

scala> val map2 = Map(1 -> 100, 3 -> 300)
map2: scala.collection.immutable.Map[Int,Int] = Map(1 -> 100, 3 -> 300)

scala> map1 |+| map2
res2: scala.collection.immutable.Map[Int,Int] = Map(1 -> 109, 3 -> 300, 2 -> 20)

具体来说，用于Map[K, V]合并映射键的二进制运算符，将V的半组运算符折叠到任何重复值上。标准半组Int使用加法运算符，因此您将获得每个重复键的值之和。

编辑：根据用户482745的要求，提供更多细节。

从数学上讲，半群只是一组值，以及一个运算符，该运算符从该集中获取两个值，并从该集中产生另一个值。因此，加法+运算中的整数是一个半群，例如- 运算符将两个int合并为另一个int。

您还可以在“具有给定键类型和值类型的所有映射”的集合上定义一个半组，只要您能提出一些操作，将两个映射组合在一起以生成一个新映射，这就是两者的组合输入。

如果两个地图中都没有按键，这是微不足道的。如果两个映射中都存在相同的键，那么我们需要组合键映射到的两个值。嗯，我们不是刚刚描述了一个将两个相同类型的实体组合在一起的运算符吗？这就是为什么在Scalaz一个半群Map[K, V]当且仅当一个半群的存在，V存在- V的半群用于将值从被分配到相同的密钥两张地图结合起来。

因此，因为Int这里是值类型，所以1键上的“冲突” 是通过两个映射值的整数相加来解决的（因为这是Int的半组运算符所做的事情）100 + 9。如果值是Strings，则冲突将导致两个映射值的字符串串联（同样，因为这是String的半组运算符所做的事情）。

（有趣的是，因为字符串连接是不可交换的-那就是"a" + "b" != "b" + "a"-生成的半群操作也不那么，map1 |+| map2是从不同map2 |+| map1的字符串的情况下，而不是在诠释情况。）

我知道的仅使用标准库的最短答案是

map1 ++ map2.map{ case (k,v) => k -> (v + map1.getOrElse(k,0)) }

快速解决方案：

(map1.keySet ++ map2.keySet).map {i=> (i,map1.getOrElse(i,0) + map2.getOrElse(i,0))}.toMap

好吧，现在在scala库中（至少在2.10中），您需要一些东西- 合并函数。但是它仅在HashMap中显示，而在Map中不显示。这有点令人困惑。签名也很麻烦-无法想象为什么我需要两次密钥，以及何时需要与另一个密钥产生配对。但是尽管如此，它比以前的“本机”解决方案更有效并且更清洁。

val map1 = collection.immutable.HashMap(1 -> 11 , 2 -> 12)
val map2 = collection.immutable.HashMap(1 -> 11 , 2 -> 12)
map1.merged(map2)({ case ((k,v1),(_,v2)) => (k,v1+v2) })

同样在scaladoc中提到

merged与进行遍历并从头开始构造新的不可变哈希图相比，该方法的平均性能更高++。

可以将其实现为仅具有普通Scala 的Monoid。这是一个示例实现。使用这种方法，我们不仅可以合并2个地图，还可以合并一个地图列表。

// Monoid trait

trait Monoid[M] {
  def zero: M
  def op(a: M, b: M): M
}

Monoid特征的基于Map的实现，该实现合并了两个地图。

val mapMonoid = new Monoid[Map[Int, Int]] {
  override def zero: Map[Int, Int] = Map()

  override def op(a: Map[Int, Int], b: Map[Int, Int]): Map[Int, Int] =
    (a.keySet ++ b.keySet) map { k => 
      (k, a.getOrElse(k, 0) + b.getOrElse(k, 0))
    } toMap
}

现在，如果您有一个需要合并的地图列表（在这种情况下只有2个），则可以按照以下步骤进行操作。

val map1 = Map(1 -> 9 , 2 -> 20)
val map2 = Map(1 -> 100, 3 -> 300)

val maps = List(map1, map2) // The list can have more maps.

val merged = maps.foldLeft(mapMonoid.zero)(mapMonoid.op)

map1 ++ ( for ( (k,v) <- map2 ) yield ( k -> ( v + map1.getOrElse(k,0) ) ) )

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

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

基本上使用scalaz semi group，您可以轻松实现

看起来像：

  import scalaz.Scalaz._
  map1 |+| map2

您也可以使用Cats做到这一点。

import cats.implicits._

val map1 = Map(1 -> 9 , 2 -> 20)
val map2 = Map(1 -> 100, 3 -> 300)

map1 combine map2 // Map(2 -> 20, 1 -> 109, 3 -> 300)

开始时Scala 2.13，另一个仅基于标准库的解决方案包括替换groupBy您的解决方案部分，groupMapReduce其名称（如其名称所示）等同于groupBy后跟mapValues和减少步骤：

// val map1 = Map(1 -> 9, 2 -> 20)
// val map2 = Map(1 -> 100, 3 -> 300)
(map1.toSeq ++ map2).groupMapReduce(_._1)(_._2)(_+_)
// Map[Int,Int] = Map(2 -> 20, 1 -> 109, 3 -> 300)

这个：

• 将两个地图串联为一个元组（List((1,9), (2,20), (1,100), (3,300))）。为了简洁，map2被隐式转换为Seq适应类型map1.toSeq-但你可以选择，使其明确使用map2.toSeq，

• group的元素基于它们的第一个元组部分（组 MapReduce的组部分），

• map将值分组到第二个元组部分（Map Reduce 组的映射部分），

• reduce_+_通过对它们的映射值（）求和（减少groupMap Reduce的一部分）。

这是我最终使用的内容：

(a.toSeq ++ b.toSeq).groupBy(_._1).mapValues(_.map(_._2).sum)

Andrzej Doyle的答案很好地说明了半组，使您可以使用|+|运算符来连接两个映射并求和匹配键的值。

有很多方法可以将某些内容定义为类型类的实例，并且与OP不同，您可能不想专门对键进行求和。或者，您可能希望对联合而不是交叉点进行操作。为此，Scalaz还添加了其他功能Map：

https://oss.sonatype.org/service/local/repositories/snapshots/archive/org/scalaz/scalaz_2.11/7.3.0-SNAPSHOT/scalaz_2.11-7.3.0-SNAPSHOT-javadoc.jar/!/ index.html＃scalaz.std.MapFunctions

你可以做

import scalaz.Scalaz._

map1 |+| map2 // As per other answers
map1.intersectWith(map2)(_ + _) // Do things other than sum the values

最快最简单的方法：

val m1 = Map(1 -> 1.0, 3 -> 3.0, 5 -> 5.2)
val m2 = Map(0 -> 10.0, 3 -> 3.0)
val merged = (m2 foldLeft m1) (
  (acc, v) => acc + (v._1 -> (v._2 + acc.getOrElse(v._1, 0.0)))
)

通过这种方式，每个元素的立即添加到地图。

第二种++方法是：

map1 ++ map2.map { case (k,v) => k -> (v + map1.getOrElse(k,0)) }

与第一种方法不同，第二种方法是为第二张地图中的每个元素创建一个新的List并将其连接到上一张地图。

该case表达式使用unapplymethod 隐式创建一个新的List 。

这就是我想出的...

def mergeMap(m1: Map[Char, Int],  m2: Map[Char, Int]): Map[Char, Int] = {
   var map : Map[Char, Int] = Map[Char, Int]() ++ m1
   for(p <- m2) {
      map = map + (p._1 -> (p._2 + map.getOrElse(p._1,0)))
   }
   map
}

使用typeclass模式，我们可以合并任何数值类型：

object MapSyntax {
  implicit class MapOps[A, B](a: Map[A, B]) {
    def plus(b: Map[A, B])(implicit num: Numeric[B]): Map[A, B] = {
      b ++ a.map { case (key, value) => key -> num.plus(value, b.getOrElse(key, num.zero)) }
    }
  }
}

用法：

import MapSyntax.MapOps

map1 plus map2

合并一系列地图：

maps.reduce(_ plus _)

我有一个小的函数来完成这项工作，它在我的小图书馆中，用于某些常用的功能，而这些功能不在标准库中。它应该适用于所有类型的可变且不可变的地图，不仅适用于HashMaps

这是用法

scala> import com.daodecode.scalax.collection.extensions._
scala> val merged = Map("1" -> 1, "2" -> 2).mergedWith(Map("1" -> 1, "2" -> 2))(_ + _)
merged: scala.collection.immutable.Map[String,Int] = Map(1 -> 2, 2 -> 4)

https://github.com/jozic/scalax-collection/blob/master/README.md#mergedwith

这是身体

def mergedWith(another: Map[K, V])(f: (V, V) => V): Repr =
  if (another.isEmpty) mapLike.asInstanceOf[Repr]
  else {
    val mapBuilder = new mutable.MapBuilder[K, V, Repr](mapLike.asInstanceOf[Repr])
    another.foreach { case (k, v) =>
      mapLike.get(k) match {
        case Some(ev) => mapBuilder += k -> f(ev, v)
        case _ => mapBuilder += k -> v
      }
    }
    mapBuilder.result()
  }

https://github.com/jozic/scalax-collection/blob/master/src%2Fmain%2Fscala%2Fcom%2Fdaodecode%2Fscalax%2Fcollection%2Fextensions%2Fpackage.scala#L190