@[TOC](kotlin 关键字 扩展函数)

前言

使用纯代码 加 注释的方式，可以更快的理解源码
如果你喜欢，请点个赞，后期会不断的深入讲解

1、reified 关键字

//    1、新建三个数据类，用于随机生成对象
//    2、randomOrDefault() 函数，备用机制Lambda
//    3、随机生成一个 对象

//    <ObjectClass1>   指定的对象
    TestClass().randomOrDefault<ObjectClass1> {
        println("由于随机产生的对象 和我们指定的不一样，启用备用对象")
        ObjectClass1("备用的对象，大王五", 99)
    }

data class ObjectClass1(val name: String, val age: Int)
data class ObjectClass2(val name: String, val age: Int)
data class ObjectClass3(val name: String, val age: Int)

class TestClass {


//    所有的功能，都写在函数上
//    默认随机输出一个对象，如果此对象和指定的对象不一致，就启用备用对象，否则直接返回对象
   inline fun <reified T> randomOrDefault(defaultLambdaAction:() ->T) : T? {
        val objList = listOf(
            ObjectClass1("obj1 tiger", 18), ObjectClass2("obj2 张三", 38), ObjectClass3("obj3 王美丽", 28)
        )
//        随机选择最后一个对象
        val randomObj = objList.shuffled().last()
        println("随机产生的对象是：$randomObj")

//       如果 it 生成的对象等于T的类型，就会走as T 直接返回了
        return randomObj.takeIf { it is T } as T?   // null as T    null as T?
//       如果 it 随机产生的对象 不等于 T类型，就直接走下面的备用还节
            ?: defaultLambdaAction()
    }

}

2、定义扩展函数

在kotlin 中，可扩展的函数有很多，下面举几个例子：

    ObjectClass1("张三", 22).show()
    ObjectClass1("tiger", 22).getInfo()

    println("tiger".addExtAction(3))

//    增加扩展函数show()

fun ObjectClass1.show(){
    println("我是新增的show函数：name： $name, age：$age")
}

//    增加扩展函数getInfo()

fun ObjectClass1.getInfo(){
    println("我是新增的getInfo函数：name： $name, age：$age")
}

//   字符串 扩展
fun String.addExtAction(number: Int) = this + "@".repeat(number)

data class ObjectClass1(val name: String, val age: Int)

3、可空类型函数扩展

    "tiger".outPutStringValue("传null 就走这里")
    null.outPutStringValue("传null 就走这里")


//  String 不可空的情况下，只能传值，在可空的情况下，可以传 null
//  defaultValue 添加一个备用函数，在传值为 null 的情况下，返回 defaultValue 备用内容
fun String?.outPutStringValue(defaultValue: String){
    println(this ?: defaultValue)
}

4、infix 关键字

infix 中缀表达式，可以简化代码。需要加 扩展函数才能使用哦

//    条件一：对第一个参数 O1.test() 函数扩展
//    条件二：需要在 括号（o2: o2）参数里面，传递一个参数
    "tiger".test("18")
    "tiger" test ("18")
    123 test ("18")

//    map 自带的有中缀表达式哦
    val mapOf = mapOf("tiger" to 2)
    println(mapOf)

infix fun <O1, O2> O1.test(o2: O2) {
    println("中缀表达式第一个参数的内容是：$this")
    println("中缀表达式第二个参数的内容是：$o2")
}

5、变换函数 Map

//    原理：就是把 匿名函数 最后一行的返回值，加入到一个新的集合，新集合的泛型是R，并且返回集合
    val listOf = listOf("张三", "王美丽", "大漂亮")
    val map = listOf.map {
        "[$it]"
    }.map {
        "你给啥，我都敢加 $it"
    }

    println(map)

6、变换函数 flatMap

//    原理：就是把 匿名函数 最后一行的返回值，加入到一个新的集合，新集合的泛型是R，并且返回集合
    val listOf = listOf("张三", "王美丽", "大漂亮")         
    val map = listOf.map {
        "[$it]"          // 每次返回一个string 
    }.flatMap {
        listOf("$it 你给啥=我都敢加","$it 表示不服","$it 觉得王美丽丑")    // 每次返回一个集合
    }

    println(map)

7、filter 过滤函数

//    filter 函数使用非常的简单， 但是得是一个集合
    val listOf1 = listOf("张三", "王美丽", "大漂亮")
    val listOf2 = listOf("张s", "刘芳", "王五")
    val ls2 = listOf(listOf1, listOf2)
    val map = ls2.flatMap { it ->
        it.filter {
           it.contains('张')
        }
    }

//    输出打印的是一个数组，元素只有 包含 contains('张') 的
    println(map)

8、合并操作符

//    原理：就是把一个集合 和 第二个集合 合并起来，创建新的集合， 并返回
//    创建新的集合（元素，元素，元素） 元素Pair(K, V) 代替第一个集合元素 V代替第二个集合的元素
    val listOf1 = listOf("张三", "王美丽", "大漂亮")
    val listOf2 = listOf(45, 18, 21)

    val zip = listOf1.zip(listOf2)
    println(zip)

//    遍历
    zip.forEach {
        println("姓名是：${it.first} 年龄是：${it.second}")
    }

    zip.toMap().forEach{
        k, v ->
        println("姓名是：${k} 年龄是：${v}")
    }

9、补充 kotlin 单例的实现

//kotlin 单例模式的实现

class KotlinInstance private constructor() {
    companion object {
        val instance: KotlinInstance by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
            KotlinInstance()
        }
    }

    fun show(){
        println("show")
    }
}

总结

🤩
🎉 $\textcolor{blue}{原创不易，还希望各位大佬支持一下}$

👍 $\textcolor{green}{点赞，你的认可是我创作的动力！}$

🌟 $\textcolor{green}{收藏，你的青睐是我努力的方向！}$

✏️ $\textcolor{green}{评论，你的意见是我进步的财富！}$