Kotlin之精选

偏执的太偏执、 2022-11-27 03:23 156阅读 0赞

## 1 如何巧用Kotlin内置函数？ ##

### 1.1 let、also、with、run、和apply区别？ ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70]

### 1.2 until、step、downTo、in 等关键字 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70 1]

### 1.2 使用示例区别？ ###

### 1.2.1 let ###

private fun higherFunCompare() {
        
            val people : People = People("chen", 1, listOf("x", "y"))
    
            /**
             * let
             * 作用：1.避免写判空的处理；2.使用it替代object对象在其作用域内访问属性&方法；3.返回值是最后一行 == return ...
             */
            val let = people?.let {
        
                it.age
                it.name
                it.isYong()
                it.isMen()
                999
            }
            LogUtils.d(TAG, "people?.let：$let")
            // people?.let：999
    
            // java
            if (people != null) {
        
                people.age
                people.name
                people.isYong()
                people.isMen()
                999
            }
        }

### 1.2.2 also ###

private fun higherFunCompare() {
        
            /**
             * also：类似let函数，但区别在于返回值：
             * 3.返回值是传入的对象的本身
             */
            val also = people?.also {
        
                it.age
                it.name
                it.isYong()
                it.isMen()
                999
            }
            LogUtils.d(TAG, "people?.also：$also")
            // people?.also：com.read.kotlinlib.model.People@1f24758d
        }

### 1.2.3 with ###

private fun higherFunCompare() {
        
            /**
             * with：
             * 1.调用同一个对象的多个方法/属性时，省去重复的对象名，直接调用方法名/属性即可；2.返回值是最后一行
             */
            val with = with(people) {
        
                LogUtils.d(TAG,"my name is $name, I am $age years old, ${isYong()}, ${isMen()}")
                999
            }
            LogUtils.d(TAG, "with(people)：$with")
            // my name is chen, I am 1 years old, false, true
            // with(people)：999
    
            // java
            LogUtils.d(TAG,"my name is $people.name, I am $people.age years old, ${people.isYong()}, ${people.isMen()}")
        }

### 1.2.4 run ###

private fun higherFunCompare() {
                
            /**
             * run：结合了let、with两个函数的作用
             * 作用：1.避免写判空的处理；2.使用it替代object对象在其作用域内访问属性&方法；3.返回值是最后一行；
             *      4.调用同一个对象的多个方法/属性时，省去重复的对象名，直接调用方法名/属性即可
             */
            val run = people?.run {
        
                LogUtils.d(TAG,"my name is $name, I am $age years old, ${isYong()}, ${isMen()}")
                999
            }
            LogUtils.d(TAG, "people?.run：$run")
            // my name is chen, I am 1 years old, false, true
            // people?.run：999
        }

### 1.2.5 apply ###

private fun higherFunCompare() {
        
            /**
             * apply：与run函数类似，但区别在于返回值：
             * 3.返回值是传入的对象的本身；
             */
            val apply = people?.apply {
        
                LogUtils.d(TAG,"my name is $name, I am $age years old, ${isYong()}, ${isMen()}")
                999
            }
            LogUtils.d(TAG, "people?.apply：$apply")
            // my name is chen, I am 1 years old, false, true
            // people?.apply：com.read.kotlinlib.model.People@1f24758d
        }

### 1.3 参考链接 ###

[如何巧用Kotlin内置函数？][Kotlin]

## 2 函数 ##

// 函数返回一个Int类型的值。并且接受了一个block()函数作为该函数的参数；
    // 其中block()接受一个Char类型的参数，并且返回一个Int类型的值，默认值是一个返回值为1的代码块：{1}
    
    // sumBy函数参数是一个扩展在CharSequence类型下的函数，
    // 同理block()函数参数也是一个扩展在CharSequence类型下的函数，可以缩写；
    fun CharSequence.sumBy(block: CharSequence.(char: Char) -> Int = {
         1 }): Int {
         
        // == CharSequence.sumBy(block: (Char) -> Int): Int {
        
    }

// block 本身是一个函数
    // 当一个函数被内联 inline 标注后，在调用它的地方，会把这个函数方法体中的所以代码移动到调用的地方，而不是通过方法间压栈进栈的方式，从而使得方法的调用栈少一层
    // 应该使用 inline 的地方： 带有 lambda 参数的函数
    inline fun measure(block: () -> Unit): Long {
        
        val start = System.currentTimeMillis()
        block()
        return System.currentTimeMillis() - start
    }
    
    // 当不添加 inline 时，代码中，多出了一个类，增加内存的分配；
    // 类是：com/read/kotlinlib/basic/CoroutineActivity$testBlock$4.INSTANCE : Lcom/read/kotlinlib/basic/CoroutineActivity$testBlock$4
    inline fun measureStr(block: (str: String) -> Unit): Long {
          // == fun measureStr(block: (String) -> Unit): Long {
        
        val start = System.currentTimeMillis()
        block("measureStr")
        return System.currentTimeMillis() - start
    }

## 3 for循环 ##

// 正序遍历
        for (index in 0..10){
        
        	print(index) //输出012345678910
        }
       
        // 倒序遍历
        for (index in 10 downTo 1){
        
        	print(index) //输出10987654321
        }
       
        // 不使用1作为遍历的步长
        for (index in 0..10 step 2){
        
        	print(index) //输出0246810
        }
      
        // 一个不包含末尾元素的区间：
        for (index in 0 until 10){
        
        	print(index) //输出0123456789
        }
       
        // 遍历一个数组/列表，想同时取出下标和元素：
        val arrays = arrayOf("a", "b", "c")
        for ((index,e) in arrays.withIndex()){
        
        	print("下标=$index--元素=$e") //输出下标=0--元素=a 下标=1--元素=b 下标=2--元素=c
        }
     
        // 遍历一个数组/列表，只取出下标:
        for (index in arrays.indices){
        
        	print("index=$index") //输出index=0 index=1 index=2
        }
       
        // 遍历取元素：
        for (element in arrays){
        
        	print("element=$element") //输出element=a element=b element=c
        }

[参考链接：kotlin for循环的几种使用方法][kotlin for]

## 4 变量 ##

### 4.1 const val 和val修饰对象的主要区别 ###

const val 可见性为public final static，可以直接访问。
    val 可见性为private final static，并且val 会生成方法getNormalObject()，通过方法调用访问。

## 4 单例最佳写法 ##

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

class SingletonDemo private constructor() {
        
        companion object {
        
            val instance = SingletonHolder.holder
        }
    
        private object SingletonHolder {
        
            val holder= SingletonDemo()
        }
    }

companion object {
        
            @Volatile
            private var instance: DiscoveryRepository? = null
    
            fun getInstance() = run {
        
                instance ?: synchronized(this) {
        
                    instance ?: DiscoveryRepository().also {
         instance = it }
                }
            }
        }

## 5 Java中调用Kotlin会遇到的坑？ ##

### 5.1 @JvmField ###

var mWaitingDialog: WaitingDialog? = null

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70_pic_center]  
![在这里插入图片描述][20201016105940959.png_pic_center]

@JvmField  
    var mWaitingDialog: WaitingDialog? = null

@JvmField 将Kotlin属性作为字段暴露，使用@JvmField注解对其标注。该字段将具有与底层属性相同的可见性。否则，通过getMWaitingDialog()，kotlin会默认生成get\\set方法

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70]: /images/20221124/16e00e25cf644798a9d0f9bf6a77d076.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70 1]: /images/20221124/b8719a61ef0e432496e983333da7dfb7.png
[Kotlin]: https://mp.weixin.qq.com/s/QDv6Fjx-0XxmcPSM68ODKQ
[kotlin for]: https://www.jianshu.com/p/27646c6561a7
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70_pic_center]: /images/20221124/2f0238184b5f4e17931e509ee96d3bb7.png
[20201016105940959.png_pic_center]: /images/20221124/7c604e0226ce4fb58fda7ef5196c8221.png