¿La mejor manera de combinar dos mapas y sumar los valores de la misma clave?

La respuesta más corta que conozco que solo usa la biblioteca estándar es

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

Solución rápida:

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

Bueno, ahora en la biblioteca scala (al menos en la 2.10) hay algo que querías - fusionado función. PERO se presenta solo en HashMap, no en Map. Es algo confuso. También la firma es engorrosa - no puedo imaginar por qué necesitaría una clave dos veces y cuando tendría que producir un par con otra clave. Pero sin embargo, funciona y mucho más limpio que las soluciones "nativas" anteriores.

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

También en scaladoc mencionó que

El método merged es en promedio más performant than doing a atravesar y reconstruir un nuevo mapa hash inmutable desde scratch, o ++.

Esto se puede implementar como un Monoide con Scala simple. Aquí hay una implementación de ejemplo. Con este enfoque, podemos combinar no solo 2, sino una lista de mapas.

// Monoid trait

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

La implementación basada en mapas del rasgo Monoide que fusiona dos mapas.

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
}

Ahora, si tiene una lista de mapas que necesita fusionarse (en este caso, solo 2), se puede hacer como a continuación.

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

Escribí una entrada de blog sobre esto, échale un vistazo:

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

Básicamente usando scalaz semi group puedes lograr esto bastante fácilmente

Se vería algo así como:

  import scalaz.Scalaz._
  map1 |+| map2

También puedes hacer eso con Gatos.

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)

La respuesta de Andrzej Doyle contiene una gran explicación de los semigrupos que le permite usar el operador |+| para unir dos mapas y sumar los valores de las claves coincidentes.

Hay muchas maneras en que algo se puede definir como una instancia de una clase de tipo, y a diferencia del OP, es posible que no desee sumar sus claves específicamente. O, es posible que desee operar en un sindicato en lugar de una intersección. Scalaz también agrega funciones adicionales a Map para esto propósito:

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

Puedes hacer

import scalaz.Scalaz._

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

Esto es lo que se me ocurrió...

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
}

Tengo una pequeña función para hacer el trabajo, está en mi pequeña biblioteca para alguna funcionalidad de uso frecuente que no está en la librería estándar. Debería funcionar para todo tipo de mapas, mutables e inmutables, no solo HashMaps

Aquí está el uso

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

Y aquí está el cuerpo

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

La forma más rápida y sencilla:

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

De esta manera, cada uno de los elementos se agrega inmediatamente al mapa.

El segundo camino ++ es:

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

A diferencia de la primera manera, de una segunda manera para cada elemento en un segundo mapa se creará una nueva Lista y se concatenará con el mapa anterior.

La expresión case crea implícitamente una nueva Lista usando el método unapply.