Qué tal si:

 val unionList = (mapA.asSequence() + mapB.asSequence()) .distinct() .groupBy({ it.key }, { it.value }) .mapValues { (_, values) -> values.joinToString(",") }

Resultado:

 {Emergency=112,911, Fire department=101, Police=102}

Esta voluntad:

• producir una Sequence perezosa de los pares clave-valor de ambos mapas
• agrúpelos por clave (resultado: Map<String, List<String> )
• asigne sus valores a cadenas unidas por comas (resultado: Map<String, String> )

Puedes hacer lo siguiente:

 (mapA.keys + mapB.keys).associateWith { setOf(mapA[it], mapB[it]).filterNotNull().joinToString() }

1. poner todas las llaves en un juego
2. iterar sobre ese conjunto y asociar cada elemento con el conjunto de valores
3. eliminar los valores nulos del conjunto de valores
4. concatene los elementos en la lista de valores usando joinToString() .

Mientras miraba las otras soluciones, no podía creer que no haya una manera más fácil (o formas tan fáciles como la respuesta aceptada sin la necesidad de recrear un Map , nuevas listas intermedias, etc.). Aquí hay 3 (de muchas ;-)) soluciones que se me ocurrieron:

1. Usando las claves y mapeando los valores más tarde:

    (mapA.keys.asSequence() + mapB.keys) .associateWith { sequenceOf(mapA[it], mapB[it]) // one of the sides may have null values in it (ie no entry in the map)... .filterNotNull() .distinct() .toList() // or if you require/prefer, do the following instead: joinToString() }

2. Usando groupingBy y fold (o eche un vistazo a: Group by key y fold cada grupo simultáneamente (KEEP) ):

    (mapA.asSequence() + mapB.asSequence()) .groupingBy { it.key } .fold({ _, _ -> mutableSetOf() }) { _, accumulator, element -> accumulator.apply { add(element.value) } }

   También podría usar una String vacía en su lugar y concatenar en la operación de plegado de la manera que lo necesite. Mi primer enfoque solo usó una sequenceOf de en lugar de MutableSet . Depende de lo que necesites y de lo que quieras hacer con el resultado después. Asegúrese de utilizar la función de fold sobrecargada que acepta un selector de valor inicial, que crea un nuevo valor inicial cada vez que se encuentra una nueva clave. Gracias xzt por notarlo.

3. Usando Javas Map.merge , pero ignorando los duplicados en el valor y también simplemente concatenando los valores:

    val mergedMap: Map<String, String> = mapA.toMutableMap().apply { mapB.forEach { key, value -> merge(key, value) { currentValue, addedValue -> "$currentValue, $addedValue" // just concatenate... no duplicates-check.. } } }

   Esto, por supuesto, también se puede escribir de manera diferente, pero de esta manera nos aseguramos de que mergedMap siga siendo solo Map<String, String> cuando se accede de nuevo.