Kotlin常见用法

使用心得：kotlin 比java 的优点在于空指针安全。以及各种简化操作符等。书写美观快速开发


kotlin 几种单利模式
https://www.jianshu.com/p/5797b3d0ebd0

 let,with,run,apply,also函数区别
https://blog.csdn.net/u013064109/article/details/78786646

       //kotlin 的集中for，不包含迭代器的方式
            val al =listOf("ab","ab","ab","ab","ab","ab")
            //对象方式
            for( value in al){
            }
            //下标
            for( index in    5..6 ){
            }
            //倒叙
            for( index in    6 downTo 1 ){
            }
            //键/值
            for( (index,value) in  al.withIndex() ){
            }
            //类似map
            for(  index  in  al.withIndex() ){
                index.index
                index.value
            }
            //forEach
            al.forEach {
            }
            //下标跟值
              al.forEachIndexed   {index,s->

            }  //下标
            for( i in al.indices){
            }
            //下标
            for( i in al.indices){
            }
            //下标
            loop@for( i in al.indices){
            }
//关于@符号
    loop1@ run loop2@      {
        loop3@for( i in al.indices){
            //结束循环
            return@loop3
        }
    }
    //loop1代表整个run的代码
      //loop3代表整个当前循环
      //loop2 代表本次run 时候的action

     常用的kotlin 加减乘除

      //    val a=1;
            a.unaryPlus(); //+a
            a.unaryMinus() //-a
            a.inc() //a++ /++a
            a.dec() //a- /-a
            a.plus(4) //a+4
            a.minus(5)//a+5
            a.times(5)//a*5
            a.div(5)//a/5

//kotlin 给java属性暴露
    @JvmField //适用于变量
    var isLogin: Boolean = false
    @JvmStatic //适用于方法
    //重命名class外面的静态类名称可以去掉kt带有kt的静态类问题
    @file:JvmName("AD")

 

koltin list转map: associateBy

  kotlin过滤操作符
https://www.cnblogs.com/Jetictors/p/9241867.html

关于集合的操作符，直接引用书上的内容，基本上总结的很好了。
val list = listOf(1, 2, 3, 4, 5, 6)

drop
返回包含去掉前n个元素的所有元素的列表。

assertEquals(listOf(5, 6), list.drop(4))
dropWhile
返回根据给定函数从第一项开始去掉指定元素的列表。

assertEquals(listOf(3, 4, 5, 6), list.dropWhile { it < 3 })
dropLastWhile
返回根据给定函数从最后一项开始去掉指定元素的列表。

assertEquals(listOf(1, 2, 3, 4), list.dropLastWhile { it > 4 })
filter
过滤所有符合给定函数条件的元素。

assertEquals(listOf(2, 4, 6), list .ilter { it % 2 == 0 })
filterNot
过滤所有不符合给定函数条件的元素。

assertEquals(listOf(1, 3, 5), list.filterNot { it % 2 == 0 })
filterNotNull
过滤所有元素中不是null的元素。

assertEquals(listOf(1, 2, 3, 4), listWithNull.filterNotNull())
slice
过滤一个list中指定index的元素。

assertEquals(listOf(2, 4, 5), list.slice(listOf(1, 3, 4)))
take
返回从第一个开始的n个元素。

assertEquals(listOf(1, 2), list.take(2))
takeLast
返回从最后一个开始的n个元素

assertEquals(listOf(5, 6), list.takeLast(2))
takeWhile
返回从第一个开始符合给定函数条件的元素。

assertEquals(listOf(1, 2), list.takeWhile { it < 3 })
https://blog.csdn.net/yu540135101/article/details/113246177

 

协程使用

android {
//解决kotlin 使用java1.8特性的问题
    kotlinOptions {
    jvmTarget = '1.8'
    }
    //协程开启
    kotlin {
        experimental {
            coroutines 'enable'
        }
    }
    ......
    }

 

协程:
1.launch 2. async 3.runBlocking
区别:
 launch不会阻断协程。
 async** 支持返回动的协程任务会阻断当前协程**，直到该协程执行结束。当协程执行结束之后，页面才会被显示出来。
协程上下文:
Dispatchers.Main：使用这个调度器在 Android 主线程上运行一个协程。可以用来更新UI 。在UI线程中执行
Dispatchers.IO：这个调度器被优化在主线程之外执行磁盘或网络 I/O。在线程池中执行
Dispatchers.Default：这个调度器经过优化，可以在主线程之外执行 cpu 密集型的工作。例如对列表进行排序和解析 JSON。在线程池中执行。
Dispatchers.Unconfined：在调用的线程直接执行。
启动模式
DEFAULT	默认的模式，立即执行协程体
LAZY	只有在需要的情况下运行
ATOMIC	立即执行协程体，但在开始运行之前无法取消
UNDISPATCHED	立即在当前线程执行协程体，直到第一个 suspend 调用
用法:
 runBlocking {
        }
async 用法需要搭配
        runBlocking {
        //类似flutter
            val a=  GlobalScope. async  {
                return@async "123456"
            }
         var bs=   a.await()
        }
        GlobalScope.launch {
            val a=  GlobalScope. async  {
                return@async "123456"
            }
            a.await()
        }
        GlobalScope.launch {
            L.d("协程环境运行未指定"+Thread.currentThread().name)
        }
        GlobalScope.launch(newSingleThreadContext("MyThread")) {
            L.d("协程环境运行"+Thread.currentThread().name)
        }
        GlobalScope.launch(Dispatchers.Main) {
            L.d("协程环境运行指定Main"+Thread.currentThread().name)
        }

        GlobalScope.launch(Dispatchers.Default) {
            L.d("协程环境运行Default"+Thread.currentThread().name)
        }
        GlobalScope.launch(Dispatchers.IO) {
            L.d("协程环境运行IO"+Thread.currentThread().name)
        }