Kotlin高阶函数与Lambda表达式及内联函数的介绍
目录
- 1、高阶函数
- 1.1、什么是高阶函数？
- 1.1.1、不带返回值的高阶函数
- 1.1.2、带参数且带返回值的高阶函数
- 1.1.3、与一般的函数进行比较
- 1.2、如何使用？
- 1.3、高阶函数有什么作用？
- 2、Lambda表达式
- 2.1、什么是Lambda表达式？
- 2.1.1、无参数的写法
- 2.1.2、有参数的写法
- 2.1.3、有参数且有返回值的写法
- 2.2、如何使用？
- 2.3、Lambda表达式有什么作用？
- 3、内联函数
- 3.1、什么是内联函数？
- 3.1.1、inline内联函数的写法
- 3.1.2、noinline禁止内联的写法
- 3.1.3、crossinline限制Lambda表达式直接调用 return的写法
- 3.3、如何使用？
- 3.2、内联函数有什么作用？
- 3.3.1、高阶函数为什么会造成性能损耗？
- 3.3.2、使用内联函数为什么可以解决高阶函数性能损耗问题？
- 4、总结
- 5、参考链接
1、高阶函数
1.1、什么是高阶函数？
高阶函数就是将函数类型用作参数或返回值的函数。
举例说明，看看高阶函数到底长什么样子。
1.1.1、不带返回值的高阶函数
例子如下：
private fun testA(fun1: (String) -> Unit): String {
return fun1("这是testA中")
}
这就是一个Kotlin的高阶函数的写法，注意看fun1就是我们传递的函数类型的参数。
-> String：代表的就是返回值的数据类型，也可以是Int、、Long等等；
-> Unit：代表的就是不带返回值的写法，用Unit固定表示类似java的viod用法。
1.1.2、带参数且带返回值的高阶函数
例子如下：
private fun testA(fun1: (String) -> String): String {
return fun1("这是testA中")
}
1.1.3、与一般的函数进行比较
一般的函数带参数的写法，如下：
fun test(arg:String):String{
retrun "返回值：$arg"
}
arg与fun1都是参数，kotlin的高级之处就在于，可以直接把一个函数当作形式参数(又称函数类型的参数)来用。
1.2、如何使用？
使用也不复杂，举个例子：
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
val res = testA(::testFun)
println(res);//输出：返回值：这是在testA中
}
private fun testA(fun1: (String) -> String): String {
val fun1Res= fun1("这是在testA中")
return fun1Res;
}
fun testFun(arg:String):String{
retrun "返回值：$arg"
}
1.3、高阶函数有什么作用？
可以提高代码的灵活性，以前只能传对象类型的参数或者基本类型的参数，现在可以把一个函数当作参数进行传递。
2、Lambda表达式
2.1、什么是Lambda表达式？
最简单的理解就是写在大括号里面的代码段，与匿名内部类写法非常类似。
举几个Lambda表达式的例子，看看Lambda表达式到底长什么样子：
2.1.1、无参数的写法
举个例子，如下：
{
println("Lambda表达式无参数写法")
}
2.1.2、有参数的写法
举个例子，如下：
val res3: (String, String) -> Unit = { arg: String, arg1: String ->
println("Lambda表达式有参数写法$arg , $arg1 ")
}
参数的类型可以自动推断，上面这段代码可简写为：
val res3 = { arg: String, arg1: String ->
println("Lambda表达式有参数写法$arg , $arg1 ")
}
2.1.3、有参数且有返回值的写法
举个例子，如下：
val res: (String, String) -> String = { arg: String, arg1: String ->
arg + "," + arg1 //直接返回值，不需要return关键字
}
返回值和参数的类型可以自动推断，上面这段代码可简写为：
val res = { arg: String, arg1: String ->
arg + "," + arg1 //直接返回值，不需要return关键字
}
有返回值的时候，不需要添加return 关键字，否则会提示报错如下：
'return' is not allowed here
2.2、如何使用？
使用也不复杂，举例如下：
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
testA {
println("Lambda表达式无参数写法")
}
testB { arg: String ->
println("Lambda表达式有参数写法：$arg")
}
testC { arg: String ->
println("Lambda表达式有参数且有返回值的写法：$arg")
val resArg = "返回的，$arg"
resArg
}
}
//高阶函数
private fun testA(fun1: () -> Unit) {
fun1()
}
//高阶函数
private fun testB(fun1: (String) -> Unit) {
fun1("我是参数")
}
//高阶函数
private fun testC(fun1: (String) -> String) {
val res = fun1("我是参数")
println(res)
}
2.3、Lambda表达式有什么作用？
可以大大的简化代码，当高阶函数与Lambda表达式结合，可以减少代码行数，让代码看起来更加简洁，比如我们常见到的一些MutableLiveData类型的监听等等。
举个例子，监听MutableLiveData类型的变量需要注册监听，看看原始写法：
val res= MutableLiveData<Long>()
res.observe(this,object:Observer<Long> {
override fun onChanged(t: Long?) {
TODO("Not yet implemented")
}
})
注意：在Kotlin中定义匿名内部类需要使用object关键字。
上面这段代码采用Lambda简化后的代码，如下：
val res= MutableLiveData<Long>()
res.observe(this) {
TODO("Not yet implemented")
}
效果立竿见影，超预期的简洁。
3、内联函数
3.1、什么是内联函数？
内联函数主要涉及到三个关键字：
inline(内联) ，作用于函数；
noinline(禁止内联)，作用于函数类型的参数；
crossinline（限制lambda表达式直接调用 return，导致程序执行[逻辑异常]，作用于函数类型的参数。
3.1.1、inline内联函数的写法
举个例子，如下：
private inline fun testH1( arg:String) {
println("内联函数 testH1")
}
直接在函数 fun 之前添加inline即可，这样写虽然也可以，但是AS会报一个提示：
Expected performance impact from inlining is insignificant. Inlining works best for functions with parameters of functional types
内联对性能的预期影响微不足道。内联最适合具有函数类型参数的函数
所以内联函数是为了提高高阶函数的性能，所以推荐在带有函数类型参数的地方使用。
我们改变一下例子，最终如下：
private inline fun testH( fun1: (String) -> Unit) {
println("内联函数 testH")
fun1("testD 传递的参数")
}
fun1是我们的函数类型参数，这时候使用inline关键字就不会再出现上面的提示了。
3.1.2、noinline禁止内联的写法
举个例子，如下：
private inline fun testD(noinline fun1: (String) -> Unit) {
println("inline testD")
fun1("testD 传递的参数")
}
需要在inline函数的，函数类型的参数添加noinline关键字即可，这样写虽然也可以，但是AS又会报提示：
Expected performance impact from inlining is insignificant. Inlining works best for functions with parameters of functional types
内联对性能的预期影响微不足道。内联最适合具有函数类型参数的函数
所以内联函数是为了提高高阶函数的性能，所以推荐在带有2个及以上的函数类型参数的时候使用noinline，这个有意思。
我们改变一下例子，最终如下：
private inline fun testD( fun1: (String) -> Unit,noinline fun2: (String) -> String) {
println("inline testD")
fun1("testD 传递的参数")
}
3.1.3、crossinline限制Lambda表达式直接调用 return的写法
其中前面提到的[逻辑异常]的意思是，如果在Lambda表达式中执行了return操作，会直接导致调用lambda表达式所在的函数直接终止返回。如果把lambda表达式看作子函数，这个子函数一般会在一个函数内进行使用，我们把这个子函数所在的这个函数看作父函数，这时如果在子函数中执行了return语句，则会发生奇怪的现象，父函数也立即执行了return语句。这时候想一想，如果你在主函数顺序执行多个子函数的调用，其中一个子函数是内联函数它最先被调用，如果这个内联的子函数中直接执行了return语句，那么其后的其他子函数将不会被执行。因此通过添加这个crossinline关键字就能解决这个问题，添加后会直接让内联函数的return语句编译报错，如下所示：
‘return’ is not allowed here
，编译器直接不允许这种写法。
举个正确的例子，写法如下：
private inline fun testF(crossinline fun1: (String) -> String) {
println("testF 之前")
val res = fun1("这是 testF 传递的参数")
println(res)
println("testF 之后")
}
也需要在inline标注的内联函数中，使用crossinline关键字，防止Lambda表达式直接调用 return语句，主打纠错。
3.3、如何使用？
举一个例子，把三个关键字都用上了，如下所示：
override fun onCreate(savedInstanceState: Bundle?) {
this.savedInstanceState = savedInstanceState
testD("普通参数", { arg: String ->
println("Lambda表达式对应fun1 $arg")
//return //放开就会被crossinline检测到并报错
}, { arg: String ->
println("Lambda表达式对应fun2$arg")
val resArg = "这个高阶函数fun2是带返回值$arg"
resArg
})
}
private inline fun testD(
arg: String,
crossinline fun1: (String) -> Unit,
noinline fun2: (String) -> String
) {
println("内联函数 testD$arg")
fun1("testD 传递给fun1的参数")
fun2("testD 传递给fun2的参数")
}
3.2、内联函数有什么作用？
使用高阶函数很方便，但会带来一定的性能损耗，为了解决这个问题可以使用内联函数，主打与高阶函数进行配合。
3.3.1、高阶函数为什么会造成性能损耗？
为什么说高阶函数会导致性能损耗，我们需要看下kt文件编译后生成的.java文件，进行对比就能看出端倪，开始分析。
首先，准备一份，kt文件原始代码，如下：
override fun onCreate(savedInstanceState: Bundle?) {
this.savedInstanceState = savedInstanceState
testX(::testY)
}
//高阶函数 ，无内联
private fun testX(fun1: (String) -> Unit) {
println("这是testX")
fun1("来自testX的参数")
}
private fun testY(str:String) {
println("这是testY")
}
其次，kt文件直接调用高阶函数，查看编译后生成的.java代码，如下所示：
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
this.testX((Function1)(new Function1(this) {
//这个是重写的父类函数
public Object invoke(Object p1) {
this.invoke((String)p1);
return Unit.INSTANCE;
}
//在这个匿名内部类中又临时创建了一个私有函数 invoke，并方便上面的重写的invoke函数调用 ，就是这一句this.invoke((String)p1);
public final void invoke(String p0) {
Intrinsics.checkNotNullParameter(p0, "p0");
//这个地方调用了testY
((IndexActivity)this.receiver).testY(p0);
}
}));
}
private final void testX(Function1 fun1) {
String var2 = "这是testX";
System.out.println(var2);
fun1.invoke("来自testX的参数");
}
private final void testY(String str) {
String var2 = "这是testY";
System.out.println(var2);
}
最后得出结论：
可以看到使用高阶函数后，编译的代码，直接new 了一个内部类Function1，并重写 public operator fun invoke(p1: P1): R 这个函数，同时在内部类中又单独写了一个私有函数public final void invoke(String p0) ，导致性能开销过大，所以才又内联函数的出现。
3.3.2、使用内联函数为什么可以解决高阶函数性能损耗问题？
首先，修改testX为内联函数，如下所示：
//高阶函数 ，有内联
private inline fun testX(fun1: (String) -> Unit) {
println("这是testX")
fun1("来自testX的参数")
}
其次，使用内联函数后，查看编译生成的.java代码，如下所示：
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
//就是这个地方
int $i$f$testX = false;
String var3 = "这是testX";
System.out.println(var3);
String p0 = "来自testX的参数";
int var5 = false;
this.testY(p0);
}
private final void testX(Function1 fun1) {
int $i$f$testX = false;
String var3 = "这是testX";
System.out.println(var3);
fun1.invoke("来自testX的参数");
}
private final void testY(String str) {
String var2 = "这是testY";
System.out.println(var2);
}
最后得出结论：
可以看到添加内联函数后，代码直接合并在一起了，变成了和我们用java调用普通函数一样，不会创建新的匿名内部类对象，造成性能开销，这就是内联函数的作用。
友情提示，查看kt编译后转成.java代码的方法，如下图所示：
最后,再点击弹出界面中的[Decompile]按钮即可生成。
4、总结
高阶函数及Lambda表达式的引入增加了kotlin的调用灵活性及代码的简洁性，但是又带来了性能上的问题，所以又引入了内联函数，内联函数保持和java调用函数一样的高效。
使用高阶函数一定要注意要做性能优化，也就是使用内联函数来配套使用。
5、参考链接
1、【Kotlin】Kotlin的高阶函数与Lambda表达式
原创不易，求个关注。
微信公众号：一粒尘埃的漫旅
里面有很多想对大家说的话，就像和朋友聊聊天。
写代码，做设计，聊生活，聊工作，聊职场。
我见到的世界是什么样子的？
搜索关注我吧。
公众号与博客的内容不同。