Kotlin的作用域函数以及常用操作符

一、作用域函数

1.1 使用run和let的Api

fun runAndLetApi() {
        var contentString = arrayListOf("112", null, "45", "89")
        //run没有参数，this代指contentString
        val let = contentString.run {
            forEach {
                //indexOf(it)找到it在contentString的位置
                //修改contentString对应位置的元素
                this[indexOf(it)] = it + "d"
            }
           	//返回处理后的contentString
            //let有参数，it代替run的返回值this
        }.let {
            println(it)//[112d, nulld, 45d, 89d]
            it//返回处理后的contentString
        }
    }

1.2 使用withApi

fun withApi() {
        var contentString = arrayListOf("112", null, "45", "89")
        //contentString将会调用{}中的方法
        val with = with(contentString) {
            forEach {
                //indexOf(it)找到it在contentString的位置
                //修改contentString对应位置的元素
                this[indexOf(it)] = it + "d"
            }
        }//能返回处理后的结果
    }

1.3 使用apply的Api

fun applyApi() {
        var contentString = arrayListOf("112", null, "45", "89")
        //apply没有参数，this代指contentString
        contentString.apply {

        }//不返回处理结果

1.4 使用also的Api

fun alsoApi() {
        var contentString = arrayListOf("112", null, "45", "89")
        //also有参数，用it代指contentString
        contentString.also {

        }//不返回处理结果
    }

二、takeIf 和 takeUnless

2.1 使用takeIf的Api

fun takeIfApi() {
        var contentString = arrayListOf("112", null, "45", "89")
        contentString.takeIf {
            it.size > 5 //如果有关于contentString的属性满足这个条件，那么takeIf将会返回contentString，否则返回null
        }.let {
            println("该对象为$it")
        }
    }

2.1 使用takeUnless的Api

fun takeUnlessApi() {
        var contentString = arrayListOf("112", null, "45", "89")
        contentString.takeUnless {
            it.size > 5 //如果有关于contentString的属性不满足这个条件，那么takeUnless将会返回contentString，否则返回null
        }.let {
            println("该对象为$it")
        }
    }

三、操作符

3.1 元素操作Api

 fun elementOperationsApi() {
        var contentString = arrayListOf("112", null, "45", "89")
        //常用操作符=====元素操作类
        //contains —— 判断是否有指定元素
        contentString.contains("123")  //java的Api
        //elementAt —— 返回对应的元素，越界会抛IndexOutOfBoundsException
        val elementAt = contentString.elementAt(0)//kotlin的Api
        println("elementAt::$elementAt")//112
        //firstOrNull —— 返回符合条件的第⼀个元素，没有 返回null
        val first = contentString.firstOrNull {
            it?.length == 2 //it?.length当it为null时，it?.length返回null
        }
        println("first::$first")//112
        //lastOrNull —— 返回符合条件的最后⼀个元素，没有 返回null
        val last = contentString.lastOrNull {
            it?.length == 2 //it?.length当it为null时，it?.length返回null
        }
        println("last::$last")//89
        //indexOf —— 返回指定元素的下标，没有 返回-1
        val indexOf = contentString.indexOf(null)
        println("indexOf::$indexOf")//1
        //singleOrNull —— 返回符合条件的单个元素，如有没有符合或超过⼀个，返回null
        val singleOrNull = contentString.singleOrNull {
            it?.length == 3
        }
        println("singleOrNull::$singleOrNull")
        /**
         * 因为contentString中满足"t?.length == 2"的元素个数超过两个，所以singleOrNull的值为null
         *
         * 因为contentString中满足"t?.length == 3"的元素个数为一个，所以singleOrNull的值为112
         */
    }

3.2 判断类的Api

fun checkApi() {
        var contentString = arrayListOf("112", null, "45", "89")
        //判断类
        //any —— 判断集合中 是否有满⾜条件 的元素
        /**
         * 判断contentString中是否含有null的元素，如果有则返回true否则返回false
         * 集合对象调用any,集合对象没有元素的时候，返回false
         */
        val anyResult = contentString.any {
            it == null
        }
        println("any结果::$anyResult")//运行结果是 any结果::true
        var tempContentString = arrayListOf("112", "8", "45", "89")
        //all —— 判断集合中的元素 是否都满⾜条件
        /**
         * 判断tempContentString中是否所有元素都不为null，如果是则返回true否则返回false
         * 集合对象调用all,集合对象没有元素的时候，返回true
         */
        val all = tempContentString.all {
            it != null
        }
        println("all结果::$all")//all结果::true
        //none —— 判断集合中是否 都不满⾜条件，是则返回true
        val none = tempContentString.none {
            it.length > 1
        }
        println("none结果::$none")//返回false
        //count —— 查询集合中 满⾜条件 的 元素个数
        val count = tempContentString.count {
            it.length > 1
        }
        println("count结果::$count")//返回3
        //reduce —— 从 第⼀项到最后⼀项进⾏累计
        val reduce = tempContentString.reduce { acc, s ->
            //acc是累计结果，s是下一个结果
            acc + s
        }
        println("reduce结果::$reduce")

    }

3.3 过滤的Api

fun filterApi() {
        var contentString = arrayListOf("112", null, "45", "89")
        //filter —— 过滤掉所有不满⾜条件的元素
        val filter = contentString.filter {
            it == null
        }
        println("filter之后的结果::$filter")// filter::[null]
        //filterNot —— 过滤所有满⾜条件的元素
        val filterNot = contentString.filterNot {
            it == null
        }
        println("filterNot之后的结果::$filterNot")//  filterNot::[112, 45, 89]
        //filterNotNull —— 过滤掉所有为NULL元素
        val filterNotNull = contentString.filterNotNull()
        println("filterNotNull之后的结果::$filterNotNull")
        //take —— 返回前 n 个元素
        val take = contentString.take(2)
        println("take之后的结果::$take")//take之后的结果::[112, null]
    }

3.4 转换类的Api

fun transformApi() {
        var contentString = arrayListOf("112", null, "45", "89")
        //map —— 转换成另⼀个集合
        val map = contentString.map {
            it + "a"
        }
        println("map的结果::$map")//map的结果::[112a, nulla, 45a, 89a]
        //mapIndexed —— 除了转换成另⼀个集合，还可以拿到Index(下标)
        val mapIndexed = contentString.mapIndexed { index, s ->
            println("index::$index s::$s")
            s + "a"
        }
        println("mapIndexed的结果::$mapIndexed")
        /**
         * index::0 s::112
         * index::1 s::null
         * index::2 s::45
         * index::3 s::89
         * mapIndexed的结果::[112a, nulla, 45a, 89a]
         */
        //mapNotNull —— 执⾏转换后 过滤掉 为 NULL 的元素
        val mapNotNull = contentString.mapNotNull {
            it?.let { it ->
                it + "a"
            }
        }//mapNotNull结果::[112a, 45a, 89a]
        println("mapNotNull结果::$mapNotNull")
        //flatMap —— ⾃定义逻辑合并两个集合
        var list = listOf(listOf(10, 20), listOf(30, 40), listOf(50, 60))
        println("list::$list")//list::[[10, 20], [30, 40], [50, 60]]

        var mapList = list.map { element -> element.toString() }
        println("mapList::$mapList")//mapList::[[10, 20], [30, 40], [50, 60]]

        var flatMapList = list.flatMap {
            it.asIterable()
        }
        println("flatMapList::$flatMapList")//flatMapList::[10, 20, 30, 40, 50, 60]

        //groupBy —— 按照某个条件分组，返回Map
        val groupBy = contentString.groupBy {
            it?.length
        }
        println("groupBy::$groupBy")//groupBy::{3=[112], null=[null], 2=[45, 89]}
    }

3.5 排序的Api

fun sortApi() {
        var contentString = arrayListOf(6, 3, 9, 2, 10, 7)
        //reversed —— 反序
        contentString.reverse()//调转集合
        println(contentString)//[7, 10, 2, 9, 3, 6]
        //sorted —— 升序
        contentString.sort()
        println(contentString)//[2, 3, 6, 7, 9, 10]
        //sortedDescending —— 降序
        contentString.sortDescending()
        println(contentString)//[10, 9, 7, 6, 3, 2]
        //自定义升序
        contentString.sortBy { it }
        println(contentString)//[2, 3, 6, 7, 9, 10]
        //自定义降序
        var studentList = arrayListOf<Student>(Student(9, "张三"), Student(29, "李四"), Student(15, "王五"))
        studentList.sortByDescending { it.age }
        println(studentList)//[Student(age=29, name=李四), Student(age=15, name=王五), Student(age=9, name=张三)]
    }