Kotlin常见问题和代码

记录Kotlin常见问题和代码。

6. when代替OR智能转换（20171122）

在网上看到一个问题是说有两个方法，同名不同参数

fun foo(long: Long) {...}
fun foo(int: Int) {...}

然后现在有个变量是未定类型val someValue: Any = "0" // 0 or 0L，在使用foo方法的时候，然后他是这样写的，问说如何智能转换，不要使用||。

if (someValue is Int || someValue is Long) {
    foo(someValue)
}
// 或者这样
if (someValue is Int)
    foo(someValue)
else if (someValue is Long)
    foo(someValue)

使用when来替代它

when (someValue) {
    is Long -> foo(someValue)
    is Int -> foo(someValue)
}

这样就体现了Kotlin的智能转换功能了

image

5. 同时符合until和downTo要求（20171025）

之前看到别人问了一个说想递减同时又不包含结束值怎么写？ downTo 和 until 不能并存，截图如下

image

满足他

for (i in (0 until 10).reversed()) {
    println(i)
}

但是我不是很明白他这样的需求，until又不能减掉中间的数，只能是区间的头和尾，上面的需求摆明可以这样写，

for (i in (0 until 10).reversed()) {
    println(i)
}

为什么一定要用until和downTo结合呢？？？

image

4. 使用when表达式多个case符合条件，判断要写全

使用Kotlin的when表达式来判断多个case符合条件，换成Java就是

switch(x) {
case 1:
case 2:
break;
}

这里遇到一个坑，有一个方法：

fun check(value: Any?): String = when (value) {
    is Int, Float, Double -> {
        if (value == 0) "value为0"
        else "value = $value"
    }
    else -> {
        "value为空"
    }
}

这个方法是用来判断输入的值，如果是Int、Float、Double类型的话就判断是否为0，如果不是的就返回字符串value为空。

fun main(args: Array<String>) {
    println(check(1))
    println(check(11f))
    println(check(8.01))
    println(check(0))
}

打印结果为

....居然是这样，跟我想的完全不一样，为什么会这样呢，看一下编译后的代码：

发现原因没有，只有Int类型的才有加instanceof判断，而另外两个却没有，那么得为Float和Double也加上is判断才行。

fun check(value: Any?): String = when (value) {
    is Int, is Float, is Double -> {
        if (value == 0) "value为0"
        else "value = $value"
    }
    else -> {
        "value为空"
    }
}

再来看看编译后的代码：

还有打印的结果：

3. run、let、apply和with的区别

run函数

可以看出run是一个扩展函数，并且有返回值的，将最后一行做为返回，默认返回Unit，那么我们来写个例子：

data class User(val name: String = "jowan", val age: Int = 24)

fun main(args: Array<String>) {
    val user = User()
    // runUnit类型为Unit
    val runUnit = user.run {
        println("runUnit:$this") // 打印runUnit:User(name=jowan, age=24)
    }
    println("runUnit type:$runUnit") // 打印runUnit type:kotlin.Unit
    // run类型为User
    val run = user.run {
        println("run:$this") // 打印run:User(name=jowan, age=24)
        User(age = 1)
    }
}

let函数

可以看出let也是一个扩展函数，与run函数一样，同样是有返回值，将最后一行做为返回，默认返回Unit，但是与run不同的时候，let有参数而run没有：

data class User(val name: String = "jowan", val age: Int = 24)

fun main(args: Array<String>) {
    val user = User()
    // letUnit类型为Unit
    val letUnit = user.let {
        println("letUnit:$it")
    }
    println("letUnit type:$letUnit")
    // let类型为User
    val let = user.let {
        it ->
        println("let:$it")
        User(age = 2)
    }
}

apply函数

apply

可以看出apply函数也是一个扩展函数，也有返回值，默认返回该对象，与run的区别是run返回最后一行，apply返回该对象：

data class User(val name: String = "jowan", val age: Int = 24)

fun main(args: Array<String>) {
    val user = User()
    // apply类型为User
    val apply = user.apply {
        println("apply:$this") // 打印apply:User(name=jowan, age=24)
    }
    apply.let {
        println("apply let:$it") // 打印apply let:User(name=jowan, age=24)
    }
}

with函数

with

可以看出with函数不是扩展函数，与let和apply有点像，同样是有返回值，将最后一行做为返回，默认返回Unit，并且可以直接调用对象的方法和变量：

data class User(val name: String = "jowan", val age: Int = 24)

fun main(args: Array<String>) {
    val user = User()
    // withUnit类型为Unit
    val withUnit = with(user) {
        println("withUnit:$this") // 打印withUnit:User(name=jowan, age=24)
    }
    // with类型为User
    val with = with(user) {
        println("with:$this, name:$name, age:$age") // 打印with:User(name=jowan, age=24), name:jowan, age:24
        User(age = 111)
    }
    with.let {
        println("with let:$it") // 打印with let:User(name=jowan, age=111)
    }
}

小结

函数名	返回值	参数	函数类型
run	闭包返回	无	扩展函数
let	闭包返回	it	扩展函数
apply	this	无	扩展函数
with	闭包返回	无	非扩展函数

2. 设置默认值

有这样一个问题，通过Json获取到的数据，如果获取有空的值，那么就要将其改为默认值：

data class User(val name: String?, val age: Int?)

fun main(args: Array<String>) {
    var user = User(null, 23)
    println(user.name?.let { user.name } ?: "jowan")
}

这样子写是不是很麻烦，那么这里我们可以将其写成一个方法，这样子调用的话就很方便了：

data class User(val name: String?, val age: Int?)

fun <T> T?.getDefault(default: T): T = this?.let { this } ?: default

fun main(args: Array<String>) {
    val (name, _) = User(null, 23)
    println(name.getDefault("jowan"))
    val (_, age2) = User("jowan", null)
    println(age2.getDefault(23))
}

1. 获取变量类型(getJavaClass)

使用::class.java来获取变量类型，也可以用.javaClass来获取类型。

fun main(args: Array<String>) {
    val i = "str"
    val classJava = i::class.java
    println(classJava) // 打印class java.lang.String
    val javaClass = i.javaClass
    println(javaClass) // 打印class java.lang.String
}