kotlin 变换函数map,flatMap，过滤函数filte

/**
 * DESC   : 变换函数map,flatMap，过滤函数filter
 *  zip操作符，函数式编程
 */
const val KtBaseMapFunTest01_TAG = "KtBaseMapFunTest01"

class KtBaseMapFunTest01 {

    fun testMapFun01() {
        val list = listOf<String>("zhangsan", "lisi", "wangwu")

        /**
         * 元素T,T,T -->map转换之后变成新的集合(R, R, R)
         * 原理：就是把匿名函数的最后一行作为返回值，加入新的结合，新集合的泛型类型是R,并且返回新集合。
         * */
        val list2 : List<Int>  = list.map {
            "new item $it"
            88
        }
        //list2=[88, 88, 88]
        Log.d(KtBaseMapFunTest01_TAG, "list2="+list2)


        val list3 : List<String> = list.map {
            "姓名是：$it"
        }.map {
            "[$it]"
        }.map {
            "元素：$it"
        }
        list3.forEach {
            /**
             * item=元素：[姓名是：zhangsan]
             * item=元素：[姓名是：lisi]
             * item=元素：[姓名是：wangwu]
             */
            Log.d(KtBaseMapFunTest01_TAG, "item=$it")
        }
    }

    /**
     * flatMap
     * 相当于List<List<String>> 集合的集合，嵌套关系
     */
    fun testFlatMapFun01() {
        val list = listOf<String>("zhangsan", "lisi", "wangwu")
        val list2 : List<String> = list.flatMap {
            listOf("$it 学习Kotlin", "$it 学习java", "$it 学习flutter")
        }
        /**
         * list2=[
         * zhangsan 学习Kotlin, zhangsan 学习java, zhangsan 学习flutter,
         * lisi 学习Kotlin, lisi 学习java, lisi 学习flutter,
         * wangwu 学习Kotlin, wangwu 学习java, wangwu 学习flutter]
         *
         * 原理：就是把你匿名函数的最后一行的返回值（是一个新的集合list）,加入一个新的集合，新的集合泛型是R，并且返回新集合
         */
        Log.d(KtBaseMapFunTest01_TAG, "list2="+list2)
    }

    /**
     * 过滤函数filter
     */
    fun testFilterFun01() {
        val namelist = listOf(
            listOf("zhangsan", "lisi", "wangwu"),
            listOf("zhanghong", "maqi", "liumang"),
            listOf("zhangqiang", "lixiaolong", "wangbadan")
        )


        namelist.map {
            /**
             * item=[zhangsan, lisi, wangwu]
             * item=[zhanghong, maqi, liumang]
             * item=[zhangqiang, lixiaolong, wangbadan]
             */
            Log.d(KtBaseMapFunTest01_TAG, "item=$it")
        }

        namelist.flatMap {
            /**
             * flatMap item=[zhangsan, lisi, wangwu]
             * flatMap item=[zhanghong, maqi, liumang]
             * flatMap item=[zhangqiang, lixiaolong, wangbadan]
             */
            Log.d(KtBaseMapFunTest01_TAG, "flatMap item=$it")
            listOf("")
        }

        namelist.flatMap {
            it -> it.filter {
                //filter进来了9次
                /**
                 * filter==>zhangsan filter
                 * filter==>lisi filter
                 * filter==>wangwu filter
                 * filter==>zhanghong filter
                 * filter==>maqi filter
                 * filter==>liumang filter
                 * filter==>zhangqiang filter
                 * filter==>lixiaolong filter
                 * filter==>wangbadan filter
                 */
                Log.d(KtBaseMapFunTest01_TAG, "filter==>$it filter")
                it.contains("li")//如果为true,则继续执行map函数，为false则不再执行
            }
        }.map {
            /**
             * filter...map==>lisi
             * filter...map==>liumang
             * filter...map==>lixiaolong
             */
            Log.d(KtBaseMapFunTest01_TAG, "filter...map==>$it")
        }
    }

    /**
     * zip函数
     * RxJava有zip合并操作符
     * kotlin中自带就有zip合并操作符
     *
     */
    @RequiresApi(Build.VERSION_CODES.N)
    fun testZipFun01() {
        val names = listOf<String>("zhangsan", "lisi", "wangwu")
        val ages = listOf<Int>(18,19,20)

        /**
         * 原理：
         * 就是把第一个集合通过zip合并另一个集合，创建并返回一个新的集合。
         * 创建新的集合元素（元素1，元素2，元素3），元素Pair<K,V> K代表第一个集合的元素，V代表第二个集合的元素
         */
        val zipList : List<Pair<String ,Int>> = names.zip(ages)
        //testZipFun01==>zipList=[(zhangsan, 18), (lisi, 19), (wangwu, 20)]
        Log.d(KtBaseMapFunTest01_TAG, "testZipFun01==>zipList="+zipList)
        //testZipFun01==>zipList.toMap={zhangsan=18, lisi=19, wangwu=20}
        Log.d(KtBaseMapFunTest01_TAG, "testZipFun01==>zipList.toMap="+zipList.toMap())
        //testZipFun01==>zipList.toMutableSet=[(zhangsan, 18), (lisi, 19), (wangwu, 20)]
        Log.d(KtBaseMapFunTest01_TAG, "testZipFun01==>zipList.toMutableSet="+zipList.toMutableSet())
        //testZipFun01==>zipList.toMutableList=[(zhangsan, 18), (lisi, 19), (wangwu, 20)]
        Log.d(KtBaseMapFunTest01_TAG, "testZipFun01==>zipList.toMutableList="+zipList.toMutableList())

        //遍历
        zipList.forEach {
            Log.d(KtBaseMapFunTest01_TAG, "testZipFun01==>zipList遍历=姓名：${it.first}, 年龄：${it.second}")
        }

        zipList.toMap().forEach {
            Log.d(KtBaseMapFunTest01_TAG, "testZipFun01==>zipList.toMap遍历=姓名：${it.key}, 年龄：${it.value}")
        }

        //map普通方式
        zipList.toMap().forEach { k,v ->
            Log.d(KtBaseMapFunTest01_TAG, "testZipFun01==>zipList.toMap<k,v>普通遍历=姓名：${k}, 年龄：${v}")
        }

        //map解构方式
        zipList.toMap().forEach { (k,v) ->
            Log.d(KtBaseMapFunTest01_TAG, "testZipFun01==>zipList.toMap<k,v>解构方式遍历=姓名：${k}, 年龄：${v}")
        }

        //函数式编程
        names.zip(ages).toMap().map {
            Log.d(KtBaseMapFunTest01_TAG, "testZipFun01==>zipList.toMap函数式编程=姓名：${it.key}, 年龄：${it.value}")
        }
    }
}