// 这里只记录简单使用
// 更多就访问连接：
// 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")
    }
}

fun main() {
    var v1:Test<Int> = Test<Int>()
    v1.print(1)
    var v2:Test<String> = Test<String>()
    v2.print("fd")
}

// 模板类
class Test<T>(){
    init{
    }
    
    fun print(v:T){
        println("this is " + when(v){
            is String -> "String "
            is Int -> "Int "
            else -> "Object "
        } + " " + v)
    }
}