在kotlin中将函数作为函数的入参或者返回值的函数称之为高阶函数。而我们知道lambda表达式由匿名函数而来，所以在kotlin中的高阶函数的入参或者返回值通常是lambda表达式。
1.将函数作为高阶函数的入参
首先我们来看String类中的一个函数(sumBy)的源码：
/**
* Returns the sum of all values produced by [selector] function applied to each character in the char sequence.
*/
public inline fun CharSequence.sumBy(selector: (Char) -> Int): Int {
var sum: Int = 0
for (element in this) {
sum += selector(element)
}
return sum
}
inline和CharSequence我们暂时不需要理会。我们来看下sumBy函数入参，入参是一个lambda表达式，lambda表达式，的名字为selector，入参为Char类型，返回值为Int。sumBy函数的返回值也是Int。我们再看sumBy的函数体。在sumBy函数中，遍历当前字符串的每一个字符，然后通过调用lambda表达式求和。而lambda表达式的入参是当前字符，返回的是Int。我们来看下最终的调用结果
fun main() {
val value = "weishixiong"
val sum = value.sumBy { it.toInt() }
println(sum)
}
1198
调用sumBy方法的时候，因为参数只有一个lambda表达式，所以省略了（），直接传入lambda表达式的函数体it.toInt。这个it就是遍历的每一个字符。所以上面的代码的意思就是，把每一个字符转换成Int，然后相加。
2.将函数作为高阶函数的返回值
fun <T> lock(lock: Lock, body: () -> T): T {
lock.lock()
try {
return body()
}
finally {
lock.unlock()
}
}
上面我们可以看到lock函数是一个泛型T，在函数体中返回了一个body()函数。
3.常用的标准高阶函数介绍
常用的标准高阶函数基本来自Standard类中
1.TODO函数
TODO函数其实不算高阶函数，不过它也是来自Standard类中。它的左右就是抛出一个NotImplementedError异常。
调用方式：
TODO("这是一个普通的异常")
Exception in thread "main" kotlin.NotImplementedError: An operation is not implemented: 这是一个普通的异常
at com.example.kotlin01.LambdaTestKt.main(LambdaTest.kt:76)
at com.example.kotlin01.LambdaTestKt.main(LambdaTest.kt)
源码：
@kotlin.internal.InlineOnly
public inline fun TODO(reason: String): Nothing = throw NotImplementedError("An operation is not implemented: $reason")
2.run()函数
我们先来看下run函数的源码
@kotlin.internal.InlineOnly
public inline fun <R> run(block: () -> R): R {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
return block()
}
从源码中看起来很简单，传入一个block的lambda表达式作为入参，lambda的返回值和这个函数的返回值一样。通常有两种用法：
用法1：我们需要执行一个代码，并且这个代码块是独立的。也就是我可以在run函数中写一些和项目无关的代码并不影响项目的正常运行。
fun testRun() {
val str = "kotlin"
val value = run {
val str = "Java"
str
}
println(value)
println(str)
}
Java
kotlin
在以上的代码中，testRun函数中的str和run函数中的str没有关联。互不干扰。所以执行run函数，不会影响到主函数。我们也可以看到在run函数中入参lambda 表达式的返回值是str为String类型，所以run函数返回类型也是String类型。可以简单的理解就是run函数传入了一个函数，而这个函数的返回值就是run函数的返回值。传入函数的执行结果，就是run函数的执行结果
用法2：
当一个业务逻辑都需要执行同一段代码而根据不通条件得到不同结果的时候，我们可以用run函数
fun main() {
testRun2()
}
fun testRun2() {
val index = 3
val value = run {
when (index) {
1 -> "kotlin"
2 -> "Java"
3 -> "C"
else -> "C++"
}
}.length
println(value)
}
1
3.T.run()函数
源码：
@kotlin.internal.InlineOnly
public inline fun <T, R> T.run(block: T.() -> R): R {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
return block()
}
T.run函数是扩展在T类型下的函数，所以在传入的lambda表达式中我们可以使用当前对象的上下文，也就是this.
例子：
fun main() {
testRun2()
}
fun testRun2() {
val str = "weishixiong"
val num = str.run {
length//等价于this.langth
}
println(num)
}
11
我们直接在lambda表达式中传入length，打印的时候是11，就是字符串str的长度，其实就是调用了str.length
4.with()函数
源码：
@kotlin.internal.InlineOnly
public inline fun <T, R> with(receiver: T, block: T.() -> R): R {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
return receiver.block()
}
可以看出with函数和T.run函数效果是一样的，只是with函数是普通的高阶函数，T.run函数是扩展的高阶函数。我们可以对比两个例子实现一样的效果
fun testRun2() {
val str = "weishixiong"
val num = str.run {
length//等价于this.langth
}
println(num)
val num2 = with(str,{length})
println(num2)
}
11
11
5.T.apply()函数
源码：
@kotlin.internal.InlineOnly
public inline fun <T> T.apply(block: T.() -> Unit): T {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
block()
return this
}
T.apply()函数和之前的T.run函数基本不一样，唯一不一样的是返回值，T.apply()函数返回值是当前对象this,而T.run函数返回的是lambda表达式的返回值。通常用法就是在对象设置一些属性后，再设置一些其他的属性，或者设置一些其他的操作，比如点击事件等等。
例子：为TextView设置属性后，再设置点击事件等
val mTvBtn = findViewById<TextView>(R.id.text)
mTvBtn.apply{
text = "kotlin"
textSize = 13f
...
}.apply{
// 这里可以继续去设置属性或一些TextView的其他一些操作
}.apply{
setOnClickListener{ .... }
}
6.T.also()函数
源码：
public inline fun <T> T.also(block: (T) -> Unit): T {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
block(this)
return this
}
T.also()函数和T.apply()也是基本一样的，唯一的区别就是再函数体调用lambda表达式（block）的时候，T.also()传入了当前对象this，T.apply()没有传入当前对象。
例子:
"kotlin".also {
println("结果：${it.plus("-java")}")
}.also {
println("结果：${it.plus("-php")}")
}
"kotlin".apply {
println("结果：${this.plus("-java")}")
}.apply {
println("结果：${this.plus("-php")}")
}
上面的例子调用T.also方法的时候，可以直接再lambda表达式中通过it获取到当前对象this。因为调用lambda表达式的时候传入了this，而参数只有一个，所以it就代表了当前的this。而再T.apply方法没有传入this，所以只能手动通过this来调用。还有一个区别就是T.also方法的入参是block: (T)需要传入一个T类型，而T.apply的入参是block: T.()，说明T.apply中的lambda 表达式可以直接获取到当前this对象，而T.also则不行，T.also只能拿到通过传入的this对象
7.T.let()函数
T.let可以用来避免空指针的问题
源码
public inline fun <T, R> T.let(block: (T) -> R): R {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
return block(this)
}
T.let函数和之前的函数用法基本是一样
例子
fun testRun2() {
val value = "weishixiong";
value.let {
println(it)
it.reversed()
}.let {
it.plus("aaa")
}.let { println(it) }
}
weishixiong
gnoixihsiewaaa
8.T.takeIf()函数
源码：
@kotlin.internal.InlineOnly
@SinceKotlin("1.1")
public inline fun <T> T.takeIf(predicate: (T) -> Boolean): T? {
contract {
callsInPlace(predicate, InvocationKind.EXACTLY_ONCE)
}
return if (predicate(this)) this else null
}
传入一个lamba表达式，表达式的参数是T类型，返回值是Boolean。即传入一个条件，条件成立则返回this，不成立则返回null。
例子：
fun testRun2() {
val value = "weishixiong";
val a = value.takeIf {
it.startsWith("a")
}
println(a)
}
null
fun testRun2() {
val value = "weishixiong";
val a = value.takeIf {
10>9
}
println(a)
}
weishixiong
9.T.takeUnless()函数
作用和T.takeIf()函数刚好相反
例子：
fun testRun2() {
val value = "weishixiong";
val a = value.takeUnless {
10>9
}
println(a)
}
null
10.repeat()函数
重复执行函数
源码：
@kotlin.internal.InlineOnly
public inline fun repeat(times: Int, action: (Int) -> Unit) {
contract { callsInPlace(action) }
for (index in 0 until times) {
action(index)
}
}
参数1就是重复的次数，参数而就是我们要执行的lambda表达式
例子
fun testRun2() {
val value = "weishixiong";
repeat(5,{
println(value)
})
}
weishixiong
weishixiong
weishixiong
weishixiong
weishixiong
小结：
一般重复使用同一个函数的是：T.also、T.let、T.apply。再具体的开发的时候，再去体会
