Htykuut

in https://try.kotlinlang.org/#/Kotlin%20Koans/Collections/FlatMap/Task.kt

it has sample of using flatMap and map

seems both are doing the same thing, is there a sample to show the difference of using flatMap and map?

the data type:

data class Shop(val name: String, val customers: List<Customer>)



data class Customer(val name: String, val city: City, val orders: List<Order>) {

    override fun toString() = "$name from ${city.name}"

}



data class Order(val products: List<Product>, val isDelivered: Boolean)



data class Product(val name: String, val price: Double) {

    override fun toString() = "'$name' for $price"

}



data class City(val name: String) {

    override fun toString() = name

}

the samples:

fun Shop.getCitiesCustomersAreFrom(): Set<City> =

    customers.map { it.city }.toSet()

    // would it be same with customers.flatMap { it.city }.toSet() ?



val Customer.orderedProducts: Set<Product> get() {

    return orders.flatMap { it.products }.toSet()

    // would it be same with return orders.map { it.products }.toSet()

}

Have a look at this simple example:

class Data(val items : List<String>)



fun main(args: Array<String>) {

    val data = listOf(Data(listOf("a", "b", "c")), Data(listOf("1", "2", "3")))

    val items: List<String> = data.flatMap { it.items } //[a, b, c, 1, 2, 3]

    val items2: List<List<String>> = data.map { it.items } //[[a, b, c], [1, 2, 3]]

}

With flatMap, you can merge multiple collections into one as shown with the items variable. Using map, on the other hand, simply results in a list of lists.

Note that there's a flatten extension on Iterable<Iterable<T>> and also Array<Array<T>> which you can use alternatively to flatMap:

val nestedCollections: List<Int> = listOf(listOf(1,2,3), listOf(5,4,3)).flatten()

There are three functions in play here. map(), flatten(), and flatMap() which is a combination of the first two.

Consider the following example

    data class Hero (val name:String)

    data class Universe (val heroes: List<Hero>)



    val batman = Hero("Bruce Wayne")

    val wonderWoman = Hero (name = "Diana Prince")



    val mailMan = Hero("Stan Lee")

    val deadPool = Hero("Wade Winston Wilson")



    val marvel = Universe(listOf(mailMan, deadPool))

    val dc = Universe(listOf(batman, wonderWoman))



    val allHeroes: List<Universe> = listOf(marvel, dc)



    allHeroes.map { it.heroes } // output: [[Hero(name=Stan Lee), Hero(name=Wade Winston Wilson)], [Hero(name=Bruce Wayne), Hero(name=Diana Prince)]]

    /*

        map allows you to access each universe in {allHeroes} and (in this case) return 

        its list of heroes. So the output will be a list containing two lists of heroes, 

        one for each universe.

        The result is a List<List<Hero>>

    */



    allHeroes.flatMap { it.heroes } // output: [Hero(name=Stan Lee), Hero(name=Wade Winston Wilson), Hero(name=Bruce Wayne), Hero(name=Diana Prince)]

    /*

        flatMap allows you to do the same as map, access the two lists of heroes from 

        both universes. But it goes further and flattens the returned list of lists 

        into a single list.

        The result is a List<Hero>

        */



    allHeroes.map { it.heroes }.flatten() // output: [Hero(name=Stan Lee), Hero(name=Wade Winston Wilson), Hero(name=Bruce Wayne), Hero(name=Diana Prince)]

    /*

        This produces the same result as flatMap. 

        So flatMap is a combination of the two functions, map{} and then flatten()    

    */