標準庫里面常用的高階函數(shù)的定義和用法

T.apply()函數(shù)

調(diào)用某對象的apply函數(shù)，在函數(shù)范圍內(nèi)，可以通過this調(diào)用該對象的任意方法，并返回該對象，this可以省略不寫.
apply一般用于一個對象實例初始化的時候，需要對對象中的屬性進行賦值。
函數(shù)的源碼：

public inline fun <T> T.apply(block: T.() -> Unit): T {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    block()
    return this
}

使用

fun main() {
    val result = UserEntity().apply {
        this.userId = 100
        this.userName = "華晨宇"
        this.age = 30
        println("my name is $userName, I am $age years old, my number is $userId")
    }
    println("result: $result")
}

輸出

my name is 華晨宇, I am 30 years old, my number is 100
result: userName:華晨宇,userId:100,age:30

T.let()函數(shù)

public inline fun <T, R> T.let(block: (T) -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return block(this)
}

let函數(shù)默認當前這個對象作為閉包的it參數(shù)，返回值是函數(shù)里面最后一行，或者指定return

fun main() {
    "kotlin".let {
        println("原字符串：$it")         // kotlin
        it.reversed()
    }.let {
        println("反轉(zhuǎn)字符串后的值：$it")     // niltok
        it.plus("-java")
    }.let {
        println("新的字符串：$it")          // niltok-java
    }
}

輸出

原字符串：kotlin
反轉(zhuǎn)字符串后的值：niltok
新的字符串：niltok-java

T.also()函數(shù)

public inline fun <T> T.also(block: (T) -> Unit): T {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    block(this)
    return this
}

also函數(shù)的結(jié)構(gòu)實際上和let很像唯一的區(qū)別就是返回值的不一樣，let是以閉包的形式返回，返回函數(shù)體內(nèi)最后一行的值，如果最后一行為空就返回一個Unit類型的默認值。而also函數(shù)返回的則是傳入對象的本身

fun main() {
    val result = "kotlin".also {
        println("結(jié)果：${it.plus("-java")}")
    }.also {
        println("結(jié)果：${it.plus("-php")}")
    }
    println("result：$result")
}

結(jié)果：kotlin-java
結(jié)果：kotlin-php
result：kotlin

T.run()函數(shù)

public inline fun <T, R> T.run(block: T.() -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return block()
}

在函數(shù)范圍內(nèi)，可以任意調(diào)用該對象的任意方法，返回函數(shù)里面最后一行，或者指定return

fun main() {
    val str = "kotlin"
    str.run {
        println("length = ${this.length}")
        println("first = ${first()}")
        println("last = ${last()}")
    }
}

length = 6
first = k
last = n

fun main() {
    val result = UserEntity().run {
        this.userId = 100
        this.userName = "華晨宇"
        this.age = 30
        println("my name is $userName, I am $age years old, my number is $userId")
        userName
    }
    println("result: $result")
}

my name is 華晨宇, I am 30 years old, my number is 100
result: 華晨宇

with()函數(shù)

public inline fun <T, R> with(receiver: T, block: T.() -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return receiver.block()
}

with函數(shù)接收兩個參數(shù)，一個是調(diào)用者，第二個為一個函數(shù)，在函數(shù)庫內(nèi)可以通過this指代調(diào)用者（第一個參數(shù)）來調(diào)用，返回值為函數(shù)塊的最后一行或指定return

fun main() {
    val newStr = "kotlin"
    val result = with(newStr){
        println( "length = ${this.length}" )
        println( "first = ${this.first()}")
        println( "last = ${this.last()}" )
        length
    }
    println("result: $result")
}

length = 6
first = k
last = n
result: 6

T.takeIf()函數(shù)

public inline fun <T> T.takeIf(predicate: (T) -> Boolean): T? {
    contract {
        callsInPlace(predicate, InvocationKind.EXACTLY_ONCE)
    }
    return if (predicate(this)) this else null
}

傳入一個你希望的一個條件，如果對象符合你的條件則返回自身，反之，則返回null

fun main() {
    val str = "kotlin"
    val result = str.takeIf {
        //it.startsWith("ko")
        it.startsWith("java")
    }
    println("result = $result")
}

result = kotlin
result = null

T.takeUnless()函數(shù)

public inline fun <T> T.takeUnless(predicate: (T) -> Boolean): T? {
    contract {
        callsInPlace(predicate, InvocationKind.EXACTLY_ONCE)
    }
    return if (!predicate(this)) this else null
}

如果對象符合你的條件則返回null，反之，則返回自身

fun main() {
    val list = listOf(
            UserEntity(100, "華晨宇", 30),
            UserEntity(101, "張碧晨", 31),
            UserEntity(103, "鄧紫棋", 29),
            UserEntity(103, "李宇春", 32)
    )
    for (entity in list) {
        val result = entity.takeUnless {
            it.age > 30
        }
        println("result = $result")
    }
}

result = userName:華晨宇,userId:100,age:30
result = null
result = userName:鄧紫棋,userId:103,age:29
result = null

repeat()函數(shù)

public inline fun repeat(times: Int, action: (Int) -> Unit) {
    contract { callsInPlace(action) }

    for (index in 0..times - 1) {
        action(index)
    }
}

就是重復某操作指定次數(shù)

fun main() {
    val list = listOf(
            UserEntity(100, "華晨宇", 30),
            UserEntity(101, "張碧晨", 31),
            UserEntity(103, "鄧紫棋", 29),
            UserEntity(103, "李宇春", 32)
    )
    for (entity in list) {
        if (entity.age < 30) {
            repeat(3) {
                println(entity)
            }
        }
    }
}

userName:鄧紫棋,userId:103,age:29
userName:鄧紫棋,userId:103,age:29
userName:鄧紫棋,userId:103,age:29

lazy()函數(shù)

public fun <T> lazy(initializer: () -> T): Lazy<T>
public fun <T> lazy(mode: LazyThreadSafetyMode, initializer: () -> T): Lazy<T>
public fun <T> lazy(lock: Any?, initializer: () -> T): Lazy<T>

這是一個提供延時加載能力的代理屬性，接受一個lambda并返回一個Lazy <T>實例的函數(shù)，返回的實例可以作為實現(xiàn)延遲屬性的委托： 第一次調(diào)用 get()會執(zhí)行已傳遞給lazy()的lambda表達式并記錄結(jié)果， 后續(xù)調(diào)用 get()只是返回記錄的結(jié)果。

fun main() {
    val lazyValue: UserEntity by lazy {
        println("lazy!")
        UserEntity(100, "華晨宇", 30)
    }
    //第一次訪問lazyValue，會打印"lazy!"和"華晨宇"
    println(lazyValue)
    //第二次訪問只打印結(jié)果"華晨宇"
    println(lazyValue)
}

lazy!
userName:華晨宇,userId:100,age:30
userName:華晨宇,userId:100,age:30