lambda表达式是Kotlin函数式编程的一个重要概念，要想掌握函数式编程，就必须熟练掌握lambda表达式，并掌握它的各类写法和实现，这些都是掌握函数式编程的基础。编程
lambda表达式有三大特征：微信
lambda表达式返回值老是返回函数体内部最后一行表达式的值markdown
这三种形式的lambda表达式必需要可以很是熟练的掌握，这样才能进一步的了解Kotlin和函数式编程。闭包
无参数形式为：ide
val 函数名 = { 函数体 }函数式编程
示例：函数
val hello = { println("hello kotlin") }
// 等价于函数
fun hello() {
println("hello kotlin")
}复制代码
val 函数名 : (参数1类型, 参数2类型, ...) -> 返回值类型 = { 参数1, 参数2, ... -> 函数体 }性能
val 函数名 = { 参数1:类型1, 参数2:类型2, ... -> 函数体 }this
示例：spa
val sum: (Int, Int) -> Int = { a, b -> a + b }
// 等价于
val sum = { a: Int, b: Int -> a + b }
// 等价于函数
fun sum(a: Int, b: Int): Int {
return a + b
}复制代码
只有一个参数的时候，返回值中的参数形参能够省略，引用时经过it进行引用
lambda的调用有两种方式，一种是经过()来进行调用，另外一种是经过invoke()函数进行调用，两种方式没有区别。
fun main(args: Array<String>) {
val lambda = { println("test") }
lambda()
lambda.invoke()
}复制代码
在使用lambda表达式的时候，能够用下划线(_)表示未使用的参数，表示不处理这个参数。
匿名函数形式为：
val 函数名 = fun(参数1:类型1, 参数2:类型2, ...): 返回值类型 { 函数体 }
示例：
val sum = fun(a: Int, b: Int): Int {
return a + b
}
// 等价于函数
fun sum(a: Int, b: Int): Int {
return a + b
}复制代码
所谓高阶函数，实际上就是数学中的复合函数的概念，f(g(x))。
fun cal(a: Int, b: Int, f: (c: Int, d: Int) -> Int): Int {
return f(a, b)
}
fun sum(a: Int, b: Int): Int {
return a + b
}
fun main(args: Array<String>) {
val result = cal(2, 3, ::sum)
println("result = $result")
// result = 8
}复制代码
在cal函数中的最后一个参数是 f: (a: Int, b: Int) -> Int 表示该参数是一个函数引用，函数体内调用了最后一个参数指向的函数。随后定义了sum函数，该函数就是cal函数的第三个参数。
::sum表示sum函数的引用，cal(2, 3, ::sum)这一句就至关于执行了sum(2, 3)，因此输出结果为5。
函数引用能够进一步的简化函数的调用，相似下面这个例子：
class Test {
fun doSomething() {
println("test")
}
fun doTest(f: (Test) -> Unit) {
f(this)
}
}
fun main(args: Array<String>) {
val t = Test()
// 常规写法 传入函数
t.doTest { test -> test.doSomething() }
// 使用引用函数(Test::doSomething其实是对lambda表达式{test -> test.doSomething()}的简化)
t.doTest(Test::doSomething)
}复制代码
fun cal(a: Int, b: Int, f: (a: Int, b: Int) -> Int): Int {
return f(a, b)
}
fun main(args: Array<String>) {
val sum = { a: Int, b: Int -> a + b }
val result = cal(2, 3, sum)
println("result = $result")
// result = 5
}复制代码
利用前面写的方式，将一个函数改写为lambda形式，做为参数直接赋值给cal函数。
那么更进一步，能够省略这个lambda的变量，直接将lambda表达式传入函数。
fun cal(a: Int, b: Int, f: (a: Int, b: Int) -> Int): Int {
return f(a, b)
}
fun main(args: Array<String>) {
val result = cal(2, 3, { a: Int, b: Int -> a + b })
println("result = $result")
// result = 5
}复制代码
另外，在Kotlin中调用高阶函数时，若是最后一个参数为lambda表达式，能够将lambda表达式写在外面，并且若是没有其它参数的话，小括号也是能够省略的。
fun cal(a: Int, b: Int, f: (a: Int, b: Int) -> Int): Int {
return f(a, b)
}
fun main(args: Array<String>) {
val result = cal(2, 3, { a: Int, b: Int -> a + b })
// 两种写法等价
val result2 = cal(2, 3) { a: Int, b: Int -> a + b }
println("result = $result")
// result = 5
}复制代码
fun main(args: Array) {
val sumLambda = {a: Int, b: Int -> a + b}
var numFun: (a: Int, b: Int) -> Int
numFun = {a: Int, b: Int -> a + b}
numFun = sumLambda
numFun = ::sum
numFun(1,2)
}复制代码
能够看到这个变量能够等于一个lambda表达式，也能够等于另外一个lambda表达式变量，还能够等于一个普通函数，可是在函数名前须要加上(::)来获取函数引用。
下面经过一个简单的例子来看下一些具体的lambda表达式是怎么写的。
// 匿名函数
val sum = fun(a: Int, b: Int): Int {
return a + b
}
// 具名函数
fun namedSum(a: Int, b: Int): Int {
return a + b
}
// 高阶函数
fun highSum(a: Int, b: Int, f: (Int, Int) -> Int): Int {
return f(a, b)
}
fun main(args: Array<String>) {
// 经过()来执行匿名函数sum
val add = sum(1, 2)
println(add)
// 经过lambda表达式来完成函数highSum
val add2 = highSum(3, 4) { a, b -> a + b }
println(add2)
// 经过函数引用来完成函数highSum
val add3 = highSum(5, 6, ::namedSum)
println(add3)
// forEach参数接收一个函数
args.forEach({ it: String -> println(it) })
// 去掉返回值，自动推断
args.forEach({ it -> println(it) })
// 只有一个参数的时候能够省略it
args.forEach({ println(it) })
// lambda表达式在最后一个参数能够外移
args.forEach() { println(it) }
// 函数若无参数能够去掉()
args.forEach { println(it) }
// 引用函数
args.forEach(::println)
}复制代码
相似Int、String这样的数据类型，函数的类型表示为：
(Type1, Type2, ...) -> Type
// 例如
(Int) -> Int
// 因此才有了这样的函数
fun test(a: Int, f: (Int) -> Int): Int {
return f(a)
}复制代码
其中(Int) -> Int的地位和Int、String的地位是等价的。
函数既然是一种类型，那么函数也和Int、String同样，是具备可实例化的实例的，例如Int的实例一、String的实例“xys”，那么获取函数的实例，主要客源经过下面三种方式：
fun main(args: Array<String>) {
// 引用函数
println(test(1, 2, ::add))
// 匿名函数
val add = fun(a: Int, b: Int): Int {
return a + b
}
println(test(3, 4, add))
// lambda表达式
println(test(5, 6, { a, b -> a + b }))// lambda做为最后一个参数能够提到括号外
println(test(5, 6) { a, b -> a + b })
}
fun test(a: Int, b: Int, f: (Int, Int) -> Int): Int {
return f(a, b)
}
fun add(a: Int, b: Int): Int {
return a + b
}复制代码
经过下面的例子，能够了解下lambda表达式的类型，代码以下所示。
// 无参，返回String
() -> String
// 两个整型参数，返回字符串类型
(Int, Int) -> String
// 传入了一个lambda表达式和一个整型，返回Int
(()->Unit, Int) -> Int复制代码
开发者能够经过相似上面的形式来表达lambda表达式的类型，不过和Int、String同样，lambda表达式也有本身的类，即Function类。
Kotlin封装了Function0到Function22，一共23个Function类型，分别表示参数个数从0到22。
除非使用标签指定了返回点，不然return从最近的使用fun关键字声明的函数返回。
fun main(args: Array<String>) {
var sum: (Int) -> Unit = tag@{
print("Test return $it")
return@tag
}
sum(3)
}复制代码
SAM = Single Abstract Method，即惟一抽象方法
SAM转换是为了在Kotlin代码中调用Java代码所提供的一个语法糖，即为Java的单一方法的接口，提供lambda形式的实现，例如Android中最多见的view.setOnClickListener：
// SAM convert in KT
view.setOnClickListener{
view -> doSomething
}
// Java接口
public interface OnClickListener {
void onClick(View v);
}复制代码
SAM转换是专门为Java提供的语法糖，用于将lambda表达式转换成相应的匿名类的实例。在Kotlin中实现相同的功能，只须要使用函数参数便可。
lambda表达式实际上有两种形式，一种是前面介绍的基本形式，还有一种是带接收者的形式，两种lambda表达式以下所示。
普通lambda表达式：{ () -> R }
即函数无入参，返回值为R类型。
带接收者的lambda表达式：{ T.() -> R }
即申明一个T类型的接收者对象，且无入参，返回值为R类型。
Kotlin中的拓展函数，实际上就是使用的带接收者的lambda表达式，
带接收者的lambda与普通的lambda的区别主要在于this的指向区别，T.() -> R里的this表明的是T的自身实例，而() -> R里，this表明的是外部类的实例。
fun fun1(f: (Int) -> Unit) {
f(1)
}
fun fun2(f: (Int) -> Unit) {
f(2)
}
// 使用typealias
typealias intFun = (Int) -> Unit
fun fun3(f: intFun) {
f(3)
}
fun fun4(f: intFun) {
f(4)
}
fun main(args: Array<String>) {
fun1 { println(it) }
fun2 { println(it) }
fun3 { println(it) }
fun4 { println(it) }
}复制代码
若是一个函数内部申明或者返回了一个函数，那么这个函数被称之为闭包。
函数内部的变量能够被函数内部申明的函数所访问、修改，这就让闭包能够携带状态（全部的中间值都会被放入内存中）。
开发者能够经过闭包让函数具备状态，从而能够封装函数的状态，让函数具备面向对象的特性。
在了解闭包以前，须要先了解下变量的做用域，在kotlin中，变量的做用域只有两种，即全局变量和局部变量。
那么如何在函数外部访问函数内部的局部变量呢，这就须要经过闭包来进行访问，闭包的设计就是为了能让开发者读取某个函数内部的变量。
因此闭包就是可以读取其它函数的局部变量的函数。
fun test(): () -> Int {
var a = 1
println(a)
return fun(): Int {
a++
println(a)
return a
}
}
fun main(args: Array<String>) {
val t = test()
t()
t()
}
// output
1
2
3复制代码
变量t的类型其实是一个匿名函数，因此在调用t函数执行的时候，实际上执行的是返回的匿名函数，同时，因为闭包能够携带外包的变量值，因此a的状态值被传递了下来。
闭包能够访问函数体以外的变量，这被称之为变量捕获。闭包会将捕获的变量保存在一个特殊的内存区域，从而实现闭包携带状态的功能。
class Test {
private var callBack: ((str: String) -> Unit)? = null
fun setCallback(myCallBack: ((str: String) -> Unit)) {
this.callBack = myCallBack
}
}复制代码
使用函数替代了接口的实现。
Java思想的kotlin写法
interface ICallback {
fun onSuccess(msg: String)
fun onFail(msg: String)
}
class TestCallback {
var myCallback: ICallback? = null
fun setCallback(callback: ICallback) {
myCallback = callback
}
fun init() {
myCallback?.onSuccess("success message")
}
}
fun main(args: Array<String>) {
val testCallback = TestCallback()
testCallback.setCallback(object : ICallback {
override fun onSuccess(msg: String) {
println("success $msg")
}
override fun onFail(msg: String) {
println("fail $msg")
}
})
testCallback.init()
}复制代码
使用lambda表达式替代匿名内部类实现。
class TestCallback {
var mySuccessCallback: (String) -> Unit? = {}
var myFailCallback: (String) -> Unit? = {}
fun setCallback(successCallback: (String) -> Unit, failCallback: (String) -> Unit) {
mySuccessCallback = successCallback
myFailCallback = failCallback
}
fun init() {
mySuccessCallback("success message")
myFailCallback("fail message")
}
}
fun main(args: Array<String>) {
val testCallback = TestCallback()
testCallback.setCallback({ println("success $it") }, { println("fail $it") })
testCallback.init()
}复制代码
这样去掉了接口和匿名内部类。
高阶函数的一个重要使用场景就是集合的操做，里面下面这个例子，分别使用Java和Kotlin实现了「找最大值」的方法。
data class Test(val name: String, val age: Int)
fun main(args: Array<String>) {
// Java写法
val testList = listOf(Test("xys", 18), Test("qwe", 12), Test("rty", 10), Test("zxc", 2))
findMax(testList)
// Kotlin写法
println(testList.maxBy { it.age })
println(testList.maxBy(Test::age))
}
fun findMax(test: List<Test>) {
var max = 0
var currentMax: Test? = null
for (t in test) {
if (t.age > max) {
max = t.age
currentMax = t
}
}
println(currentMax)
}复制代码
filter用于数据的筛选，相似的还有filterIndexed，即带Index的过滤器、filterNot，即过滤全部不知足条件的数据。
map用于对数据进行变换，表明了一种一对一的变换关系，它能够对集合中的数据作一次变换，相似的还有mapIndexed()。
fun main(args: Array<String>) {
val test = listOf(1, 3, 5, 7, 9)
// filter函数遍历集合并选出应用给定lambda后会返回true的那些元素
println("大于5的数 ${test.filter { it > 5 }}")
// map函数对集合中的每个元素应用给定的函数并把结果收集到一个新集合
println("平方操做 ${test.map { it * it }}")
val testList = listOf(Test("xys", 18), Test("qwe", 12), Test("rty", 10), Test("zxc", 2))
// 将一个列表转换为另外一个列表
println("只展现name ${testList.map { it.name }}")
// filter与map链式操做
println("展现age大于10的name ${testList.filter { it.age > 10 }.map { it.name }}")
}
data class Test(val name: String, val age: Int)复制代码
fun main(args: Array<String>) {
val test = listOf(1, 3, 5, 7, 9)
// all判断是否所有符合lambda表达式的条件
println("是否所有符合>10 ${test.all { it > 10 }}")
// any判断是否存在有符合lambda表达式的条件的数据
println("是否存在>8 ${test.any { it > 8 }}")
// count获取符合lambda表达式条件的数据个数
println("大于5的个数 ${test.count { it > 5 }}")
// find获取符合lambda表达式条件的第一个数据
println("第一个大于5 ${test.find { it > 5 }}")
println("最后一个大于5 ${test.findLast { it > 5 }}")
}复制代码
flatMap()表明了一个一对多的关系，能够将每一个元素变换为一个新的集合，再将其平铺成一个集合。
groupBy()方法会返回一个Map>的Map对象，其中Key就是咱们分组的条件，value就是分组后的集合。
fun main(args: Array<String>) {
val test = listOf("a", "ab", "b", "bc")
// groupBy按照lambda表达式的条件重组数据并分组
println("按首字母分组 ${test.groupBy(String::first)}")
// partition按照条件进行分组，该条件只支持Boolean类型条件，first为知足条件的，second为不知足的
test.partition { it.length > 1 }.first.forEach { print("$it、") }
println()
test.partition { it.length > 1 }.second.forEach { print("$it、") }
println()
// flatMap首先按照lambda表达式对元素进行变换，再将变换后的列表合并成一个新列表
println(test.flatMap { it.toList() })
}复制代码
sortedBy()用于根据指定的规则进行顺序排序，若是要降序排序，则须要使用sortedByDescending()，
fun main(args: Array<String>) {
val test = listOf(3, 2, 4, 6, 7, 1)
println(test.sortedBy { it })
}复制代码
take()和slice()用于进行数据切片，从某个集合中返回指定条件的新集合。相似的还有takeLast()、takeIf()等。
fun main(args: Array<String>) {
val test = listOf(3, 2, 4, 6, 7, 1)
// 获取前3个元素的新切片
println(test.take(3))
// 获取指定index组成的新切片
println(test.slice(IntRange(2, 4)))
}复制代码
fun main(args: Array<String>) {
val test = listOf("a", "ab", "b", "bc")
// reduce函数将一个集合的全部元素经过传入的操做函数实现数据集合的累积操做效果。
println(test.reduce { acc, name -> "$acc$name" })
}复制代码
前面文章提到的做用域函数就是高阶函数的一个重要实例。
当一些集合函数进行链式调用的时候，每一个函数的调用结果都将保存为一个新的临时列表，所以，大量的链式操做会产生大量的中间变量，从而致使性能问题，为了提升效率，能够把链式操做改成序列（sequance）。
调用扩展函数asSequence把任意集合转换成序列，调用toList来作反向的转换
fun main(args: Array<String>) {
val testList = listOf(Test("xys", 18), Test("qwe", 12), Test("rty", 10), Test("zxc", 2))
// 函数的链式调用
println("集合调用 展现age大于10的name ${
testList.filter { it.age > 10 }
.map { it.name }}")
// 函数的序列操做
println("序列操做 展现age大于10的name ${
testList.asSequence()
.filter { it.age > 10 }
.map { it.name }
.toList()}")
}
data class Test(val name: String, val age: Int)复制代码
一个完整的序列包括两个操做，即中间序列和末端序列，中间序列操做始终都是惰性的，末端序列操做触发全部的惰性计算。
//中间操做 //末端操做
testList.asSequence(). filter {..}.map {..}.toList() 复制代码
所以，经过序列的这种方式，就避免了产生大量中间集合，从而提升了性能。
fun main(args: Array<String>) {
val addResult = lateAdd(2, 4)
print(addResult())
}
fun lateAdd(a: Int, b: Int): Function0<Int> {
fun add(): Int {
return a + b
}
return ::add
}复制代码
在lateAdd内部定义了一个局部函数，最后返回了该局部函数的引用，对结果使用()操做符拿到最终的结果，达到延迟计算的目的。
fun main(args: Array<String>) {
val funs = mapOf("sum" to ::sum)
val mapFun = funs["sum"]
if (mapFun != null) {
val result = mapFun(1, 2)
println("sum result -> $result")
}
}
fun sum(a: Int, b: Int): Int {
return a + b
}复制代码
掌握了lambda表达式，就等于战士有了枪，多练习，多思考，才能掌握lambda表达式的精髓，为后面掌握函数式编程，打下坚实的基础。
欢迎关注个人微信公众号——Android群英传