Kotlin是否有办法展平地图 <K out T , List<V out T> 列出 <T>

Question

I would like to transform the Map to List

eg I have

mapOf("a" to listOf(1,2),
      "b" to listOf(3,4)
)

I want the result to be

listOf("a", 1, 2, "b", 3, 4)

order must be Key and its Values, Key and its Values, ...

is there some function in kotlin that could help me with that?

Answer 1

My second comment variant as answer for a Map<String, List<Int>> :

mapOf("a" to listOf(1,2),
      "b" to listOf(3,4))
     .flatMap { (key, values) -> listOf(key) + values }

which gives a List<Any> with the keys followed by their values.

This example makes use of destructuring declaration and Map.flatMap .

Answer 2

UPDATE : the answer below was written before the question was updated and changed how the map was created (see the history of the question for details). As the question now stands, the answer below will no longer work. It does work for the question as originally asked though, I believe.

@Roland is right that your map will never result in that list because there can only ever be a single value in the map against any given key. So I think you need to replace that map with a list of pairs. You can then group it and flatmap it to get your desired result:

val pairs = listOf("a" to 1, "a" to 2, "b" to 3, "b" to 4)
val result = pairs
        .groupBy { it.first }
        .flatMap { (key, values) -> listOf(key).plus(values.map { it.second }) }

Another slightly different option which you might decide is more readable is this:

val result = pairs
        .groupBy({ it.first }, { it.second })
        .flatMap { (key, values) -> listOf(key).plus(values) }

Answer 3

You can flatMap over map.entries . Have a look at this function :

val map = mapOf("a" to listOf(1,2), 
                "b" to listOf(3,4))
println(map)
val flattened : List<Any> = map.entries.flatMap {entry -> 
    //create list with key as only element, must be type <Any> to add other stuff later
    val list = mutableListOf<Any>(entry.key)
    //add values
    list.addAll(entry.value)
    list
}
println(flattened)

prints:

{a=[1, 2], b=[3, 4]}
[a, 1, 2, b, 3, 4]

@Rolands answer inspired this even simpler, more idiomatic version. It essentially does the same, but crams everything into one line:

 val flattened: List<Any> = map.flatMap {entry -> 
        listOf(entry.key) + entry.value
 }