示例代码声明

class Developer (@JvmField val name: String, val ide: String)

使用@JvmField，我们在Java中调用的时候，可以直接使用属性名，而不是对应的getter方法。

//test jvmField

Developer developer = new Developer("Andy", "Android Studio");
System.out.println(developer.getIde());// not using JvmField
System.out.println(developer.name);// using JvmField

    fun t1(name:String) = flow{
        println("flow start : $name")
        for(i in 0..3){
            kotlinx.coroutines.delay(100)
            emit("$name $i")// 向外面发一个数据
        }
    }

    runBlocking{// 所有线程一起运行（顺序的话就删除launch就好）执行线程（流）执行完
        launch {
            t1("1").collect {
                println("get1 $it")
            }
        }

        // 开启第二个流
        launch {
            t1("2").collect {
                println("get2 $it")
            }
        }

        // 同一个流监听两次
        launch {
            val t = t1("3")
            t.collect {
                println("get4 $it")
            }
            t.collect {
                println("get4 $it")
            }
        }
    }

快速创建：

(1..3).asFlow().collect { value -> println(value) }

但是你不能修改延迟，所以可以增加map处理，或者增加过虑 filter

    runBlocking {
        launch {
                (1..10).asFlow() // 一个请求流
                    .filter {
                        it % 2 == 0 // 只显示偶数
                    }
                    .map {
                        // 每个个过来的都延迟1000秒
                        delay(100)
                        "hi $it";
                    }
                    .collect { response -> // 指定变量名字，不再是it
                        println(response)
                        println(response)
                        // 这里延迟也有用的
                        delay(1000)
                    }
        }

增加数据：

(1..3).asFlow() // 一个请求流
.transform { request ->
    emit("Making request $request") 
    emit(performRequest(request)) 
}
.collect { response -> println(response) }

限制数据，例如只处理两次：

fun numbers(): Flow<Int> = flow {
    try {                          
        emit(1)
        emit(2) 
        println("This line will not execute")
        emit(3)    
    } finally {
        println("Finally in numbers")
    }
}

fun main() = runBlocking<Unit> {
    numbers() 
        .take(2) // 只获取前两个
        .collect { value -> println(value) }
} 

更多参考这个

// All examples create a function object that performs upper-casing.
// So it's a function from String to String

val upperCase1: (String) -> String = { str: String -> str.toUpperCase() } // 1

val upperCase2: (String) -> String = { str -> str.toUpperCase() }         // 2

val upperCase3 = { str: String -> str.toUpperCase() }                     // 3

// val upperCase4 = { str -> str.toUpperCase() }                          // 4

val upperCase5: (String) -> String = { it.toUpperCase() }                 // 5

val upperCase6: (String) -> String = String::toUpperCase                  // 6

println(upperCase1("hello"))
println(upperCase2("hello"))
println(upperCase3("hello"))
println(upperCase5("hello"))
println(upperCase6("hello"))

fun main() {

test("fd1",1,2)
test("fd2")

// 注意这里，要调用 toIntArray，如果直接传*arg是有类型错误
val arg = arrayOf(3,4)
test("fd3", *arg.toIntArray())

}

fun test(name:String,vararg args:Int){

println("$name size ${args.size}")
print(name)
for(it in args){
    print(" ")
    print(it)
}
print("\n")

}

这里Mammal 类外部就是不可见的

sealed class Mammal(val name: String)                                                   // 1

class Cat(val catName: String) : Mammal(catName)                                        // 2
class Human(val humanName: String, val job: String) : Mammal(humanName)

fun greetMammal(mammal: Mammal): String {
    when (mammal) {                                                                     // 3
        is Human -> return "Hello ${mammal.name}; You're working as a ${mammal.job}"    // 4
        is Cat -> return "Hello ${mammal.name}"                                         // 5     
    }                                                                                   // 6
}

fun main() {
    println(greetMammal(Human("fd", "IT")))
    println(greetMammal(Cat("Snowy")))
}