Kotlin学习——Lambda表达式

Kotin学习——Lambda表达式

具体原文章：https://www.cnblogs.com/Jetictors/p/8647888.html

一、Lambda介绍

Lambda表达式的本质是匿名函数，因为在其底层实现中还是通过匿名函数来实现的。但是在使用时不必关心起底层实现。不过Lambda的出现确实是减少了代码量的编写，同时也是代码变得更加简洁明了。

二、Lambda使用

2.1 Lambda表达式的特点

  • Lambda表达式总是被大括号括着
  • 其参数（如果存在）在->之前声明（参数类型可以省略）
  • 函数体（如果存在）在->后面

2.2 Lambda语法

1. 无参数的情况
val/var 变量名 = {操作的代码}

2. 有参数的情况
val/var 变量名 : (参数的类型，参数类型，...) -> 返回值类型 = 参数1，参数2，...} -> 操作参数的代码
 可等价于
 //此种写法：即表达式的返回值类型会根据操作的代码自推导出来
 val/var 变量名 = {参数1：类型，参数2：类型，... -> 操作参数的代码}

3. lambda表达式作为函数中的参数的时候，这里举一个例子：
fun test(a:Int,参数名：（参数1：类型，参数2：类型，...）-> 表达式返回类型){
	...
}

实例：

  • 无参数的情况
//源代码
fun test(){println("无参数")}

//lambda代码
val test = {println("无参数")}

//调用
test()	//结果为：无参数
  • 有参数的情况
//源代码
fun test(a:Int,b:Int):Int{
	return a+b
}

//lambda
val test:(Int,Int) -> Int = {a, b->a+b}
//或者
val test = {a:Int,b:Int->a+b}
//调用
test(3,5)	//结果为：8
  • lambda表达式作为函数中的参数的时候
//源代码
fun test(a :Int,b :Int):Int{
	return a+b
}

fun sum(num1:Int,num2:Int):Int{
	return num1+num2
}
//调用
test(10,sum(3,5))	//结果为：18

//lambda
fun test(a:Int,b:(num1:Int,num2:Int) -> Int):Int{
	return a+b.invoke(3,5)
}

//调用
test(10,{num1:Int,num2:Int -> num1+num2})	//结果为：18

经过上面的实例讲解与语法介绍，我们对其作出一个总结：

  1. Lambda表达式总是被大括号括着。
  2. 定义完整的Lambda表达式如上面实例中的语法2，它有其完整的参数类型标注，与表达式返回值。当我们把一些类型标注省略的情况下，就如上面实例中的语法2的另外一种类型。当它推断出的返回值类型不为Unit时，它的返回值即为->符号后面代码的最后一个（或只有一个）表达式的类型。
  3. 在上面例子中语法3的情况表示为：高阶函数，当Lambda表达式作为其一个参数时，只为其表达式提供了参数类型与返回类型，所以，我们在调用此高阶函数的时候我们要为该Lambda表达式写出它的具体实现。
  4. invoke()函数：表示为通过函数变量调用自身，因为上面例子中的变量b是一个匿名函数。

3. Lambda实践

3.1 it

  • it并不是Kotlin中的一个关键字（保留字）。
  • it是当一个高阶函数中Lambda表达式的参数只有一个的时候可以使用it来使用此参数。it可表示为单个参数的隐式名称，是Kotlin语言约定的。
    例1：
val it : Int = 0 //即it不是`Kotlin`中的关键字。可用于变量名称

例2：单个参数的隐式名称

//这里举例一个语言自带的一个高阶函数filter,此函数的作用是过滤不满足条件的值。
val arr = arrayOf(1,3,5,7,9)
//过滤掉数组中元素小于2的元素，取其第一个打印。这里的it就表示每一个元素。
println(arr.filter{it<5}.component1())

例3：

fun test(num1 : Int, bool : (Int) -> Boolean) :Int{
	return if(bool(num1)){num1}else 0
}

println(test(10,{it>5}))	//输出结果为：10
println(test(4,{it>5}))	//输出结果为：0

代码讲解：上面代码的意思是，在高阶函数test中，其返回值为Int类型，Lambda表达式以num1为条件。其中如果Lambda表达式的值为false的时候返回0，反之返回num1。故而当条件为num1>5这个条件时，当调用test函数，num1=10返回值就是10，num1 = 4返回值就是0。

3.2 下划线（_）

在使用Lambda表达式的时候，可以用下划线（_）表示未使用的参数，表示不处理这个参数。

同时在遍历一个Map集合的时候，这非常有用。
举例：

val map = mapOf("key1" to "value1","key2" to "value2","key3" to "value3")

map:forEach{
	key,value -> println("$key \t $value")
}
//不需要key的时候
map.forEach(){
	_,value -> println("$value")
}

输出结果：

key1	value1
key2	value2
key3	value3
value1
value2
value3

3.3 匿名函数

  • 匿名函数的特点是可以明确指定其返回值类型。
  • 它和常规函数的定义几乎完全相似。他们的区别在于，匿名函数没有函数名。
    例：
fun test(x : Int, y : Int) : Int{
	return x+y	//常规函数
}
fun(x : Int, y : Int) : Int{
	return x+y	//匿名函数
}

从上面的例子可以看出，匿名函数与常规函数的区别在于一个有函数名，一个没有。
匿名函数与Lambda表达式的几点区别：

  1. 匿名函数的参数传值，总是在小括号内部传递。而Lambda表达式传值，可以有省略小括号的简写写法。
  2. 在一个不带标签的return语句中，匿名函数的返回值是返回自身函数的值，而Lambda表达式的返回值是将包含它的函数中返回。

3.4 带接收者的函数字面值

在Kotlin中，提供了指定的接受者对象调用Lambda表达式的功能。在函数字面值的函数体中，可以调用该接收者对象上的方法而无需任何额外的限定符。它类似于扩展函数,它允许在函数体内访问接收者对象的成员。

  • 匿名函数作为接收者类型
    匿名函数语法允许你直接指定函数字面值的接收值类型，如果你需要使用带接收者的函数类型声明一个变量，并在之后使用它，这将非常有用。
    例：
val iop = fun Int.(other : Int) : Int = this + other
println(2.iop(3)	//输出结果为：5
  • Lambda表达式作为接收者类型
    要用Lambda表达式作为接收者类型的前提是接收者类型可以从上下文中推断出来。

3.5 闭包

  • 所谓闭包，即是函数中包含函数，这里的函数我们可以包含（Lambda表达式，匿名函数，局部函数，对象表达式）。我们熟知，函数式编程是现在和未来良好的一种编程趋势，故而Kotlin也有这一个特性。
  • 我们熟知，Java是不支持闭包的。Java是一种面向对象的编程语言，在Java中，对象是他的一等公民。函数和变量是二等公民。
  • Kotlin中支持闭包，函数和变量是它的一等公民，而对象则是它的二等公民了。
    实例：看一段Java代码
public class TestJava{

	private void test(){	
		private void test(){	//错误，因为Java中不支持函数包含函数
		}
	}

	private void test1(){}	//正确，Java中的函数只能包含在对象中
}

实例：看一段Kotlin代码

fun test1(){
	fun test2(){	//正确，因为Kotlin中可以函数嵌套函数
	}
}

下面是Kotlin中几种闭包的表现形式。

3.5.1 携带状态

例：让函数返回一个函数，并携带状态值

fun test(b : Int):()->Int{
	var a = 3
	return fun() : Int{
		a++
		return a+b
	}
}

var t = test(3)
println(t())	//  7
println(t())	//  8
println(t())	//  9

3.5.2 引用外部变量，并改变外部变量的值

例：

var sum : Int = 0
val arr = arrayOf(1,3,5,7,9)
arr.filter{it < 7}.forEach{ sum += it}

println(sum)	//输出结果为9