Is there an easy way to merge two maps of Map<S...

# announcements

[df]

Is there an easy way to merge two maps of Map<String, Foo> into one map? I know the keys of the two maps are distinct from each other. I.e. I don't want to have Map<String,List<Foo>> as a resulting map.

[Rob Elliot]

map1 + map2

[df]

Okay.. sometimes it's not a good idea to oversimplify the question. Let's say I have n maps instead of just two 🙂

[df]

List<Map<String, Foo>>

[Rob Elliot]

maps.reduce { accumulator, next -> accumulator + next }

[df]

oh

[df]

that is so much better than what I had, thank you.

[Rob Elliot]

Won’t work for an empty list though… you’d need to use fold for that

[df]

that's fine, the code guarantees the list won't be empty

[Rob Elliot]

Actually maps.reduceOrNull { accumulator, next -> accumulator + next } ?: emptyMap() would work

[dave08]

Using something like buildMap { maps.forEach { putAll(it) } } would avoid creating a new map for each iteration though...

[dave08]

Or fold with a mutablemap

[Nir]

Yeah, you really don't ever want to use a container + in a loop

[Nir]

Makes a linear operation quadratic

[df]

My brain still has a hard time to work with reduce and fold. Merging data with a few loops and a "container" is very natural, translating it to fold just melts my neurons.

[df]

had the next one where I tried to merge List<Map<String, List<String>> into Map<String, List<String>>. This time the values for the same keys should be combined. Came up with this

val familyToCodes = mutableMapOf<String, MutableList<String>>()

allAssets.forEach { assets ->
    assets.forEach { (attributeFamily, assetCodes) ->
        familyToCodes.getOrPut(attributeFamily) { mutableListOf() }
            .addAll(assetCodes)
    }
}

failed to convert it to fold or buildMaps 😉

[dave08]

val immutableFamilyToCodesMap = buildMap {
allAssets.forEach { assets ->
    assets.forEach { (attributeFamily, assetCodes) ->
        getOrPut(attributeFamily) { mutableListOf() }
            .addAll(assetCodes)
    }
}
}

[dave08]

Same thing really, just leaves you with a Map that's not mutable at the end...

[df]

Okay. I think in this case it makes the code less readable (not the biggest fan of assuming getOrPut belongs to the builder)

[Nir]

I think @dave08’s buildMap solution is probably best, especially if you have trouble with reduce/fold

[Nir]

his first one I mean

[Nir]

oops wrong dave

[Nir]

The real way you want to do this one is actually groupBy

[Nir]

Or rather, groupingBy with some aggregate etc follow up

[Nir]

but if you are already struggling with fold/reduce you may not like it. I think the buildMap solutions are a very nice compromise; buildMap has a receiver with the MutableMap API, that's not really an assumption per se