Kotlin标准库函数使用分析及介绍

Kotlin提供了一个系统库，是Java库的增强。其中有很多函数在适配了Java的类型和方法同时使用Kotlin的语法。其中一些底层的函数是使用比较广泛的

1.apply 函数

apply函数可以看做是一个配置函数。针对apply函数的调用者做一些配置，并把调用者返回。

示例：下面apply的调用者是file，调用完之后，返回的还是file，并在apply函数中，针对file做了一些配置。

    val file = File("d:\\hello.txt").apply {
        setWritable(true)
        setReadable(true)
        setExecutable(false)
    }

apply源码分析：

1）apply 用inline修饰，是一个内联函数。

2）定义了一个<T>泛型，T.apply 调用者就是T，：T apply返回的类型也是T

上面的file就相当于T

3）再看apply的参数：block: T.() -> Unit。这是一个匿名函数，T.（）->说明接收的是T的函数返回的是Unit类型。

4）在apply内部 调用了这个匿名函数block（）也就是T的

5）return this，就是apply 的返回值，返回的是当前调用apply函数的对象。

public inline fun <T> T.apply(block: T.() -> Unit): T {
    block()
    return this
}

2.let 函数

let函数会把调用者作为参数传到lambda表达式里，可以用it来代替它使用。函数执行完毕，lambda表达式返回的结果，就是let函数返回的结果。

    val hello = "Hello world".let {
        it.replace("world","kotlin")
    }
    //打印结果 Hello kotlin
    println(hello)

看下let函数的定义:

1)let函数也是一个内联函数。

2）定义了两个泛型<T,R> T.let()，说明T是let的调用者。

3）block: (T) -> R 说明let接收的是一个匿名函数，匿名函数的参数是T，返回值是R

4）: R 说明let函数的返回在也是R，也就是定义的匿名函数的返回值。

5）return block(this) 把当前调用者当做参数传进来，lambda执行结果返回

上面的示例，调用let后，会把调用者当做参数传递到匿名函数也就是lambda中，并把lambda的执行结果，当做是let的结果返回。

inline fun <T, R> T.let(block: (T) -> R): R {
    return block(this)
}

3.run函数

run函数和apply差不多，可以给调用者做配置。唯一的差别是apply返回的是当前调用者对象，而run返回的是lambda执行的结果。

    val text = File("d:\\hello.txt").run {
        setWritable(true)
        setReadable(true)
        setExecutable(false)
        readText()
    }
    println(text)

run函数分析：

1）run函数也是一个内联函数。

2）有两个泛型<T,R>,T是当前调用者，R是返回值

3）run接收一个lambda ：block: T.() -> R 调用T的方法，并且把执行结果返回

4）: R lambda的执行结果，就是run函数的执行结果。我们知道lambda默认会把最后一行的结果返回。

5）return block() 返回lambda的执行结果

inline fun <T, R> T.run(block: T.() -> R): R {
    return block()
}

4.with 函数

with函数是run的变体，他们的功能是一样的。唯一的不同是调用方式，调用with时，第一个参数需要传入一个值参。

    val hello = "Hello World"
    val h2 = with(hello) {
        replace("World", "Kotlin")
    }
    println(h2)

源码分析：

with接收两个参数，第一个是传入的值参，第二个是一个lambda表达式。

inline fun <T, R> with(receiver: T, block: T.() -> R): R {
    return receiver.block()
}

5.also

also函数和let函数类似，also也是把调用者作为参数传递给lambda，不同点是let返回的是lambda的执行结果，而also返回的是当前调用者对象，这点和apply类似。

这对这个特点，可以实现调用者的链式调用。

举个简单列子。

虽然对hello做了substring，但并不会改变hello的初始值。因为最后返回的还是调用者对象本身。

    val hello = "Hello world".also {
        println(it.count())
    }.also{
        println(it.substring(0,5))
    }
    println(hello)

源码分析：

block: (T) -> Unit also接收一个lambda，这个lambda把调用者T当参数传进来了，block(this)。

return this 又把当前对象返回回去了。

inline fun <T> T.also(block: (T) -> Unit): T {
    block(this)
    return this
}

6.takeIf

takeIf需要判断lambda表达式中结果，如果true则返回调用者对象，如果是false，则返回null。

如果需要判断某个条件是否满足，再决定是否可以给变量赋值或执行某项任务时，takeIf就很好用。takeIf类似于if语句。

示例：如果flag为true，则给hello赋值“Hello world”。

如果flag为false，则返回null，但是后面又有一个?:判断，就会给hello赋值“hello null”

    var flag = false
    val hello = "Hello world".takeIf { false } ?: "hello null"
    println(hello)

源码分析：

从if (predicate(this)) this else null可以看出，如果predicate(this)为true则返回调用者this否则返回null

 inline fun <T> T.takeIf(predicate: (T) -> Boolean): T? {
    return if (predicate(this)) this else null
}

通过源码分析，takeIf也会把调用者T当做参数传到lambda中，这样我们在lambda中就可以针对调用者做判断，满足某些条件则返回调用者对象，如果不满足，则返回null。

    val hello = "Hello world".takeIf {
        it.count() > 15
    } ?: "hello kotlin world"
    println(hello)

7.takeUnless

takeUnless刚好和takeIf相反，只有给定条件为false时，才会返回takeUnless调用者对象，否则返回null。

    val hello = "Hello world".takeUnless {
        it.count() > 15
    } ?: "hello kotlin world"
    println(hello)

源码：

if (!predicate(this)) 刚好和takeIf中的相反。

inline fun <T> T.takeUnless(predicate: (T) -> Boolean): T? {
    return if (!predicate(this)) this else null
}

到此这篇关于Kotlin标准库函数使用分析及介绍的文章就介绍到这了,更多相关Kotlin标准库函数内容请搜索编程学习网以前的文章希望大家以后多多支持编程学习网！