Kotlin——高级篇（一）：Lambda表达式详解

通过前面一系列对Kotlin讲解，相信你们已经能对Kotlin有了一个基本的认识。若是你又Java语言方面的编程经验，你可能已经不知足前面的基础语法了。从这篇文章起，就为你们讲解Kotlin语言中的高级操做。
Lambda语法在Java中已经被普遍的运用，咱们在开发Android中几乎上每个项目也会在项目中接入Lambda插件，由于Lambda确实能简少不少的代码量。无独有偶，在Kotlin中也是Lambda语法的，在这篇文章中就详细的为你们讲解Lambda语法的编写与使用，同时会后面的Kotlin——高级篇（二）：高阶函数详解与标准的高阶函数使用打下基础。

目录

1、Lambda介绍

在上面已经提到了在Java中已经被普遍的运用，可是也是在Java8的时候才支持这种Lambda表达式。在其余的编程语言中（例如：Scala语言）。而这种表达式是语法糖中的一种。值得庆幸的是，Kotlin一经开源成熟就已经支持这种语法。

Lambda表达式的本质实际上是匿名函数，由于在其底层实现中仍是经过匿名函数来实现的。可是咱们在用的时候没必要关心起底层实现。不过Lambda的出现确实是减小了代码量的编写，同时也是代码变得更加简洁明了。
Lambda做为函数式编程的基础，其语法也是至关简单的。这里先经过一段简单的代码演示没让你们了解Lambda表达式的简洁之处。

例：

// 这里举例一个Android中最多见的按钮点击事件的例子
mBtn.setOnClickListener(object : View.OnClickListener{
        override fun onClick(v: View?) {
            Toast.makeText(this,"onClick",Toast.LENGTH_SHORT).show()
        }
    })
复制代码

等价于

// 调用
mBtn.setOnClickListener { Toast.makeText(this,"onClick",Toast.LENGTH_SHORT).show() }
复制代码

2、Lambda使用

关于Lambda的使用，我这里从两个方面讲解，一是先介绍Lambda表达式的特色，二是从Lambda的语法使用讲解。

2.一、Lambda表达式的特色

古人云：欲取之，先与之。

要学习Lambda表达式语法，必先了解其特色。我在这里先总结出Lambda表达式的一些特征。在下面讲解到Lambda语法与实践时你们就明白了。即：

• Lambda表达式老是被大括号括着
• 其参数(若是存在)在 -> 以前声明(参数类型能够省略)
• 函数体(若是存在)在 -> 后面。

2.二、Lambda语法

为了让你们完全的弄明白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是一个匿名函数。

三、Lambda实践

学会了上面讲解的语法只是，相信您已能大体的编写且使用lambda表达式了，不过只会上面简单的语法还不足以运用于实际项目中复杂的状况。下面从几个知识点讲解Lambda实践的要点。

3.一、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())   
复制代码

例2这个列子只是给你们it的使用，filter高阶函数，在后面的Kotlin——高级篇（四）：集合（Array、List、Set、Map）基础章节中会为你们详细讲解，这里很少作介绍。下面为咱们本身写一个高阶函数去讲解it。关于高阶函数的定义与使用请参见Kotlin——高级篇（二）：高阶函数详解与标准的高阶函数使用这篇文章。

例3：

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

println(test(10,{it > 5}))
println(test(4,{it > 5}))
复制代码

输出结果为：

10
0
复制代码

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

3.二、下划线（_）

在使用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{                  fun(x : Int , y : Int) : Int{
常规函数：      return x + y                        匿名函数：      return x + y
            }                                                   }
复制代码

在前面的Kotlin——初级篇（七）：函数基础总结咱们讲解过单表达式函数。故而，能够简写成下面的方式。

常规函数 ： fun test(x : Int , y : Int) : Int = x + y
匿名函数 ： fun(x : Int , y : Int) : Int = x + y
复制代码

从上面的两个例子能够看出，匿名函数与常规函数的区别在于一个有函数名，一个没有。

实例演练：

val test1 = fun(x : Int , y : Int) = x + y  // 当返回值能够自动推断出来的时候，能够省略，和函数同样
val test2 = fun(x : Int , y : Int) : Int = x + y
val test3 = fun(x : Int , y : Int) : Int{
    return x + y
}

println(test1(3,5))
println(test2(4,6))
println(test3(5,7))
复制代码

输出结果为：

8
10
12
复制代码

从上面的代码咱们能够总结出匿名函数与Lambda表达式的几点区别：

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

3.四、带接收者的函数字面值

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

• 匿名函数做为接收者类型

匿名函数语法容许你直接指定函数字面值的接收者类型，若是你须要使用带接收者的函数类型声明一个变量，并在以后使用它，这将很是有用。

例：

val iop = fun Int.( other : Int) : Int = this + other
println(2.iop(3))
复制代码

输出结果为：

5
复制代码

• Lambda表达式做为接收者类型

要用Lambda表达式做为接收者类型的前提是接收着类型能够从上下文中推断出来。

例：这里用官方的一个例子作说明

class HTML {
    fun body() { …… }
}

fun html(init: HTML.() -> Unit): HTML {
    val html = HTML()  // 建立接收者对象
    html.init()        // 将该接收者对象传给该 lambda
    return html
}


html {       // 带接收者的 lambda 由此开始
    body()   // 调用该接收者对象的一个方法
}
复制代码

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.一、携带状态

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

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

val t = test(3)
println(t())
println(t())
println(t())
复制代码

输出结果：

7
8
9
复制代码

3.5.二、引用外部变量，并改变外部变量的值

例：

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

println(sum)
复制代码

输出结果：

9
复制代码

3.6 在Android开发中为RecyclerView的适配器编写一个Item点击事件

class TestAdapter(val context : Context , val data: MutableList<String>)
    : RecyclerView.Adapter<TestAdapter.TestViewHolder>(){

    private var mListener : ((Int , String) -> Unit)? = null

    override fun onBindViewHolder(holder: TestViewHolder?, position: Int) {
        ...
        holder?.itemView?.setOnClickListener {
            mListener?.invoke(position, data[position])
        }

    }

    override fun onCreateViewHolder(parent: ViewGroup?, viewType: Int): TestViewHolder {
        return TestViewHolder(View.inflate(context,layoutId,parent))
    }

    override fun getItemCount(): Int {
        return data.size
    }

    fun setOnItemClickListener(mListener : (position : Int, item : String) -> Unit){
        this.mListener = mListener
    }

    inner class TestViewHolder(itemView : View) : RecyclerView.ViewHolder(itemView)
}

// 调用
TestAdapter(this,dataList).setOnItemClickListener { position, item ->
        Toast.makeText(this,"$position \t $item",Toast.LENGTH_SHORT).show()
    }
复制代码

总结

Lambda表达式是为咱们减小了大量的代码，可是Lambda表达式是为后面的高阶函数章节打下基础，虽然在这篇文章中也提到了高阶函数，可是都是最基础的，在下一节中会为你们介绍自定义高阶函数与Kotlin自身中经常使用的高阶函数讲解。

在这一章节中，讲述了Lambda的语法、使用。以及Lambda表达式的一些特性与实践操做。固然还包含了匿名函数这一知识点。其中最重要的当属Lambda的实践操做。若是你看完这篇文章还不甚理解，请在仔细的阅读一遍并实际代码演练，由于在后面的高阶函数章节还会遇到。

在这最后但愿您能给个关注，由于您的关注，是我继续写文章最好的动力。

个人我的博客：Jetictors
Github：Jteictors

欢迎各位大佬进群共同研究、探索

QQ群号：497071402