Слияние значений в карте kotlin

    val mapA = mapOf("Emergency" to "112", "Fire department" to "101", "Police" to "102")
    val mapB = mapOf("Emergency" to "911", "Police" to "102")

    val result = (mapA.entries + mapB.entries)
        .groupBy({ it.key }, { it.value })
        .mapValues {(_, value) -> 
            value.joinToString(", ")
        }

Я бы написал что-то вроде

fun Map<String, String>.mergeWith(another: Map<String, String>): Map<String, String> {
  val unionList: MutableMap<String, String> = toMutableMap()
  for ((key, value) in another) {
    unionList[key] = listOfNotNull(unionList[key], value).toSet().joinToString(", ")
  }
  return unionList
}

val mergedMap = mapA.mergeWith(mapB)

Как насчет:

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

Результат:

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

Это будет:

• создаст ленивый Sequence ключей обеих карт. пары значений
• группируют их по ключу (результат: Map<String, List<String>)
• сопоставляют их значения со строками, объединенными запятыми (результат: Map<String, String>)

Вы можете сделать следующее:

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

1. поместить все ключи в набор
2. итерировать по этому набору и связать каждый элемент с набором значений
3. удалить нулевые значения из набора значений.
4. объединить элементы в списке значений, используя joinToString().

Другой подход:

val mapA = mapOf("Emergency" to "112", "Fire department" to "101", "Police" to "102")
val mapB = mapOf("Emergency" to "911", "Police" to "102")

val result = mapA.toMutableMap()
mapB.forEach {
    var value = result[it.key]
    value = if (value == null || value == it.value) it.value else value + ", ${it.value}"
    result[it.key] = value
}

Или с использованием инфиксной функции расширения :

infix fun Map<String, String>.mergeWith(anotherMap: Map<String, String>): Map<String, String> {
    val result = this.toMutableMap()
    anotherMap.forEach {
        var value = result[it.key]
        value = if (value == null || value == it.value) it.value else value + ", ${it.value}"
        result[it.key] = value
    }
    return result
}

val result = mapA mergeWith mapB

Хотя я смотрел на другие решения, я не мог поверить, что не существует более простого способа (или способов, столь же простых, как принятый ответ, без необходимости воссоздания Map, промежуточных новых списков и т. Д.). Вот 3 (из многих ;-)) решений, которые я придумал:

1. Использование ключей и сопоставление значений позже:

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

2. [ 1121] Используя groupingBy и fold (или взгляните на: Группируйте по ключу и складывайте каждую группу одновременно (KEEP) ): [1121 ]

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

   Вы также можете просто использовать пустой String и объединять в операции сгиба так, как вам это нужно. Мой первый подход просто использовал sequenceOf вместо MutableSet. Это зависит от того, что вам нужно и что вы хотите сделать с результатом впоследствии.

3. Использование Javas Map.merge , но игнорирование дубликатов в значении и просто конкатенация значений:

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

   Это, конечно, также можно записать по-другому , но таким образом мы гарантируем, что mergedMap по-прежнему будет просто Map<String, String> при повторном доступе.