run
可以將 run 想像成一個獨立出來的 Scope ， run 會把最後一行的東西回傳或是帶到下一個 chain。
第一個例子像是：
(就是弄一个作用域出来，更SB一点做法就像if(true){})

fun main(args : Array<String>){
    val test = "fd"
    run{
        val test = "fd2"
        println("test2 $test")
    }
    
    println("test1 $test")
}

输出：
test2 fd2
test1 fd

2.*.run 就是省略前某对象名字。直接调用他的属性或方法：

fun main(args : Array<String>){
    var v:V? = V()
    v?.name = "fd"
    v?.run{
        v.t1("hi")
    }
}

class V {
    var name = "fd"
    
    fun t1(v:String){
        println("test1 $v $name")
    }
}

3.run 是支持返回值的

fun main(args : Array<String>){
    val v1 = run{
        "xxx yyy"
    }
    
    println(v1)
}

4.组合作用

fun main(args : Array<String>){
    println("hi run:" + run{
        "hahaha run"
    })
    
    run{
        var v = V()
        v.name = "fd"
        println("test2 ${v.name}")
        v // 这个对象。作为返回对象
    }.t1("vvvv")
}

class V {
    var name = "fd"
    
    fun t1(v:String){
        println("test1 $v $name")
    }
}

// 这里只记录简单使用
// 更多就访问连接：
// https://www.kotlincn.net/docs/reference/map-operations.html
fun main() {
    var map = mutableMapOf(1 to "fd", 2 to "luck")
    println("所有key:${map.keys}")
    println("所有value:${map.values}")
    
    // 这是错误的。定义使用什么类型作Key或Value，那使用过程不能变
    // map["1"]="fd one"
    // map[4] = 1
    
    // 过滤,还有filterKeys，filterValues
    val filteredMap = map.filter { (key, value) -> key == 1 && value == "fd"}
    println("过滤后的Map:$filteredMap")

    map[3]="hello"
    
    // 删除2
    println("删除Map的Value：${map.remove(2)}")
    
    map.entries.forEach{
        println("${it.key} : ${it.value}")
    }
    
}

fun main() {
    println("测试：" + Test.CHANG_LIANG)
    println("测试2：" + Test.JING_TAI)
    Test.JING_TAI = "静态被修改"
    println("测试3：" + Test.JING_TAI)
}

class Test{
    companion object{
        public const val CHANG_LIANG:String = "常量"
        public var JING_TAI:String = "静太"
    }
}

输出：

测试1：常量
测试2：静太
测试3：静态被修改

相当于Java new Thread后再runUiThread

// 必须先这样,这样是使用主线程，也可以GlobalScope.launch{},就是使用 EmptyCoroutineContext
GlobalScope.launch(Dispatchers.Main) {
    // 异步处理，如果这里是XXX函数也行办法接，do1();
    // 并且可以这样 suspend fun do1(){}定义，suspend 表示这个函数很费CPU，可以得到编译优化
    withContext(Dispatchers.IO){
        var tmp = URL("https://www.baidu.com").readText()
        // 转回UI线程
        withContext(Dispatchers.Main){
             txt.text = tmp;
        }
    }
}

多个协程同时运行并且需要一起结束的时候：

import kotlinx.coroutines.*
fun main() {
    // 自动等待所有线程结束
    runBlocking{
        launch{
            delay(1000L)
            println("thread1")
        }
        launch{
            delay(1000L)
            println("thread2")
        }
        
        // 相同功能的线程可以用
        repeat(100_000) { // 启动大量的协程 10万个
            launch{
                print(".")
            }
        }
        
        println("Main")
    }
}

超时：

    runBlocking {
        launch {
            withTimeoutOrNull(300){
                for(i in 0..10){
                    delay(100)
                    println("time $i")
                }
            }
        }
    }

更详细参考：www.kotlincn.net

fun main() {
    println(TestUtil.now)
    TestUtil.test1()
}

// object 开头 相当于static class复合体
// 这样每个方法都是静态的了
object TestUtil{
    val now:String
        get(){
                return "test"
            }
    fun test1(){
        println("test1")
    }
}