Agregar dos mapas en Groovy mientras se resumen los valores para las claves comunes

Question

Tengo dos mapas en Groovy [a: 1, b: 2] y [b:1, c:3] y me gustaría crear un tercer mapa [a: 1, b: 3, c: 3]. ¿Hay algún comando Groovy que haga eso?

Editar: Observe que los valores en el tercer mapa, son una suma de los valores de los dos primeros mapas, si las claves son idénticas.

Gracias

Answer 1

Sin embargo, otra solución sería ser:

def m1 = [ a:1, b:2 ] 
def m2 = [ b:1, c:3 ] 

def newMap = [m1,m2]*.keySet().flatten().unique().collectEntries { 
    [ (it): [m1,m2]*.get(it).findAll().sum() ] 
} 

Tomando epidemian's answer como inspiriation, también puede escribir un método para manejar múltiples mapas

def m1 = [a: 1, b: 2] 
def m2 = [b: 1, c: 3] 

def combine(Map... m) { 
    m.collectMany { it.entrySet() }.inject([:]) { result, e -> 
    result << [ (e.key):e.value + (result[ e.key ] ?: 0) ] 
    } 
} 

def newMap = combine(m1, m2) 

Answer 2

No creo que hay un método ya preparado para esto, tal vez usar algo como:

def m1 = [a: 1, b: 2] 
def m2 = [b: 1, c: 3] 
def newMap = (m1.keySet() + m2.keySet()).inject([:]) { 
    acc, k -> acc[k] = (m1[k] ?: 0) + (m2[k] ?: 0); acc 
} 

Answer 3

Esto lo hace:

Map additionJoin(Map map1, Map map2) 
{ 
    def result = [:]; 
    result.putAll(map1); 
    result.putAll(map2); 

    result.each { key, value -> 
    if(map1[key] && map2[key]) 
    { 
     result[key] = map1[key] + map2[key] 
    } 
    } 

    return result; 
} 

def a = [a: 1, b: 2] 
def b = [b:1,c:3] 

def c = additionJoin(a, b) 

println c 

Answer 4

Esto debería funcionar para cualquier número de mapas:

def maps = [[a: 1, b: 2], [b:1, c:3]] 

def result = [:].withDefault{0} 
maps.collectMany{ it.entrySet() }.each{ result[it.key] += it.value } 

assert result == [a: 1, b: 3, c: 3] 

La expresión maps.collectMany{ it.entrySet() } devuelve una lista de entradas de mapa, como [a=1, b=2, b=1, c=3], y luego cada uno de ellos se agrega al resultado.

Otra opción, si desea mantener toda la transformación en una expresión y hacerla "más funcional", es agrupar primero las entradas por clave y luego sumar los valores, pero creo que es menos legible:

def result = maps.collectMany{ it.entrySet() } 
    .groupBy{ it.key } 
    .collectEntries{[it.key, it.value.sum{ it.value }]} 

la parte groupBy devuelve un mapa de la forma [a:[a=1], b:[b=2, b=1], c:[c=3]] y luego los collectEntries transformaciones que el mapa en otra que tiene el mismo kays pero tiene la suma de las listas en los valores en su lugar.

Answer 5

Una buena manera es usar el operador de difusión:

def m1 = [ a:1, b:2 ] 
def m2 = [ b:1, c:3 ] 
def m3 = [ *:m1, *:m2 ] 

println "m1 = $m1" 
println "m2 = $m2" 
println "m3 = $m3" 

* Crédito: http://mrhaki.blogspot.ch/2009/09/groovy-goodness-spread-operator.html

El código anterior no funciona en groovysh pero está muy bien en la consola maravilloso. (Para la versión 1.8)

Answer 6

El siguiente ejemplo muestra cómo agregar dos mapas, a un tercer mapa m3:

Map m1 = [ a:1, b:2 ]; 
Map m2 = [ b:1, c:3 ]; 
Map m3 = [:]; 
m3 << m1 
m3 << m2 

Answer 7

def merge(map1, map2) { 
    def add = { map, entry -> map << entry } 
    map2.inject(map1.inject([:], add), add) 
}