Kotlin-从地图列表到按键分组的地图

我有一个

列表

，我想在单个

映射中转换它

因此，如果我有一个只有两个元素的初始列表：

名单

我想以以下方式结束：

地图

这是一种groupBy，使用初始嵌套映射中键的所有值

我试过了

list.groupBy{it-> it.keys.first()} 

但很明显，它不起作用，因为它只使用第一个键。我想要相同的，但使用所有键作为单个值

在科特林，最惯用的方法是什么？我有一个丑陋的Java工作版本，但我很肯定Kotlin有一个很好的方法来实现它。。只是到目前为止我还没有找到它

有什么想法吗

谢谢
我写了这个

data class Branch(val name: String)
data class Key(val name: String)
data class Value(val name: String)


val sharedBranch = Branch("1")
val listOfMaps: List<Map<Branch, Pair<Key, Value>>> = listOf(
        mapOf(sharedBranch to Pair(Key("1"), Value("1")),
                Branch("2") to Pair(Key("2"), Value("2"))),
        mapOf(sharedBranch to Pair(Key("1a"), Value("1a")))
)

val mapValues: Map<Branch, List<Pair<Key, Value>>> = listOfMaps.asSequence()
        .flatMap { map -> map.entries.asSequence() }
        .groupBy(Map.Entry<Branch, Pair<Key, Value>>::key)
        .mapValues { it.value.map(Map.Entry<Branch, Pair<Key, Value>>::value) }

println(mapValues)

数据类分支（val名称：字符串）
数据类键（val名称：字符串）
数据类值（val名称：字符串）
val sharedBranch=分支机构（“1”）
val listofmap:List=listOf(
映射（共享分支到对（键（“1”）、值（“1”），
分支（“2”）到配对（键（“2”）、值（“2”），
映射（共享分支到对（键（“1a”）、值（“1a”））
)
val mapValues:Map=listOfMaps.asSequence（）
.flatMap{map->map.entries.asSequence（）}
.groupBy（Map.Entry:：key）
.mapValues{it.value.map（map.Entry:：value）}
println（映射值）

它是否适用于您的需要？
以下内容：

val result =
    listOfMaps.asSequence()
        .flatMap {
          it.asSequence()
        }.groupBy({ it.key }, { it.value })

将为您提供类型为
Map
的
结果以及您请求的内容。
将其提取到扩展函数中

private fun <K, V> List<Map<K, V>>.group(): Map<K, List<V>> =
        asSequence().flatMap { it.asSequence() }.groupBy({ it.key }, { it.value })

val list:list=listOf（）
val映射=列表
.flatMap{it.entries}
.groupBy{it.key}
.mapValues{entry->entry.value.map{it.value}
其他人都在使用<代码>平面图< /C> >，但是你也可以考虑使用<代码>折叠> /COD>，这是一个普通的操作，用于将更大的集合缩小为更小的集合。（例如，您可以将
整数列表折叠成一个和；这里，将一个映射列表折叠成一个映射）

也许其他人会发现这比上面的
flatMap
版本更容易阅读：

val listofmap:List=。。。
val mergedMaps:映射=
地图列表
.fold（mutableMapOf（））{acc，curr->
curr.forEach{entry->acc.merge（entry.key，listOf（entry.value））{new，old->new+old}
行政协调会
}

上述代码正在执行的操作：


创建一个新的空地图。这将是
acc
（即累加器）
反复浏览我们的地图列表
一次处理一张地图（
curr
）
对于当前映射，运行其每个键/值对
对于每个键/值，在
acc
上调用
merge
，传入一个大小为1的列表（包装值）。如果尚未与键关联，则添加该列表；否则，它将附加到已经存在的列表中
返回累积贴图，以便在下一步中再次使用
@TimCastelijns，Kotlin的
Map
和
MutableMap
接口在JVM上不包含此方法，这是合法的Kotlin:
val Map=mutableMapOf（1到“a”，2到“b”）；map.merge（1，“c”）{v0，v1->v0+v1}
@TimCastelijns我试过写它，但是
merge
不太合适，你可以用
compute
来做。不过，这并不是对groupBy解决方案的巨大胜利
val result=mutableMapOf（）；listofmap.forEach{map->map.forEach{k，v->result.compute（k）{uUv0->v0？。还有{it.add（v）}？：mutableListOf（v）}}}
@MarkoTopolnik是的，但如果您将mutable map作为参数返回给您，则是这样。否则，您将被迫创建过多的副本。我没有写的是非法的，我写的是
Kotlin的Map
接口没有这个方法我的代码没有复制，而你的代码没有。
groupBy
和
mapValues
都会返回一个新地图。谢谢，它可以正常工作。仅供参考，我在这里做了改变：嗯。。。你可以说，它实际上最终会出现在一张地图上。。。
.mapValues
也可以简化为：
.mapValues{it.value.toMap（）}
val result =
    listOfMaps.asSequence()
        .flatMap {
          it.asSequence()
        }.groupBy({ it.key }, { it.value })

private fun <K, V> List<Map<K, V>>.group(): Map<K, List<V>> =
        asSequence().flatMap { it.asSequence() }.groupBy({ it.key }, { it.value })

val list = yourListOfMaps
val grouped = list.group()

val list: List<Map<Branch, Pair<String, Any>>> = listOf() 
val map = list
    .flatMap { it.entries }
    .groupBy { it.key }
    .mapValues { entry -> entry.value.map { it.value } }