详解Kotlin中的Lambda

最新推荐文章于 2024-03-23 14:32:01 发布

置顶宁一城

最新推荐文章于 2024-03-23 14:32:01 发布

阅读量569

点赞数 2

分类专栏： kotlin高级 Java高级文章标签： Kotlin Lambda 高阶函数 java 函数式编程

本文链接：https://blog.csdn.net/weixin_46055193/article/details/106857331

版权

Java高级同时被 2 个专栏收录

8 篇文章 0 订阅

订阅专栏

kotlin高级

5 篇文章 1 订阅

订阅专栏

详解Kotlin中的Lambda

在这里插入图片描述

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() }

二、Lambda使用

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

2.1、Lambda表达式的特点

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

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

2.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

最后一个的实现可能大家难以理解，但请不要迷茫，你继续看下去，在下面的实践和高阶函数中会为大家介绍。

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

lambda表达式总是被大括号括着。

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

Lambda表达式的简化规则

labmda表达式作为函数参数：

people.maxBy({ p: Person -> p.age} )

如果 lambda 表达式是函数调用的最后一个实参，它可以放到括号的外边。

people.maxBy(){ p: Person -> p.age}

当 lambda 是函数唯一实参时，还可以去掉代码中的空括号对：

people.maxBy{ p: Person -> p.age}

如果 lambda 参数的类型可以被推导出来，你就不需要显示地指定它：

people.maxBy{ p -> p.age}

可使用默认参数名称 it 命名参数。如果当前上下文期望的是只有一个参数的 lambda 且这个参数的类型可以推导出来，就会生成这个名称：

people.maxBy{ it.age}

如果使用变量存储 lambda，那么久没有可以推断出参数类型的上下文，所以你必须显示地指定参数类型：

val getAge = {p: Person -> p.age}
people.maxBy(getAge)

此外，如果 lambda 表达式由多个语句构成，那么最后一个表达式就是 lambda 的结果：

val sum = { x: Int, y: Int ->
    println("Computing the sum of $x and $y...")
    x + y
}
println(sum(1, 2))

3、Lambda实践

学会了上面讲解的语法只是，相信您已能大致的编写且使用lambda表达式了，不过只会上面简单的语法还不足以运用于实际项目中复杂的情况。下面从几个知识点讲解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}))
println(test(4,{it > 5}))

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{                  fun(x : Int , y : Int) : Int{
常规函数：      return x + y                        匿名函数：      return x + y
            }                                                   }

常规函数 ： 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.4、带接收者的函数字面值

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

匿名函数作为接收者类型
匿名函数语法允许你直接指定函数字面值的接收者类型，如果你需要使用带接收者的函数类型声明一个变量，并在之后使用它，这将非常有用。

例：

val iop = fun Int.( other : Int) : Int = this + other
println(2.iop(3))

输出结果为：

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.1、携带状态
例：让函数返回一个函数，并携带状态值

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.2、引用外部变量，并改变外部变量的值
例：

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

println(sum)

输出结果：

3.5 高阶函数

我们知道，lambda 的应用场景就是高阶函数，我们可以把一个 lambda 当做参数传递到高阶函数中，获取返回一个 lambda。
准确的来说，高阶函数就是以另一个函数作为参数或者返回值的函数。

调用作为参数的函数

fun twoAndThree(operation: (Int, Int) -> Int){
    //调用函数类型的参数
    val result = operation(2, 3)
    println("The result is $result")
}

fun main(arg: Array<String>) {
    twoAndThree{ a, b -> a + b}
    twoAndThree{ a, b -> a * b}
}

在 Java 中使用函数类

使用 Java 调用 Kotlin 函数类型时，函数类型会被声明为普通的接口：一个函数类型的变量时 FunctionN 接口的一个实现。Kotlin 定义了一系列接口，这些接口对应不同参数数量的函数：Function0(没有参数的函数)、Function1<P1,R>(一个参数的函数)等等。每个接口定义了一个 invoke 方法。
Java 8 中的 lambda 会被自动转成函数类型的值。
Kotlin 中 Unit 类型是有一个值的，所以需要显示的返回它，一个返回 void 的 lambda 不能作为返回 Unit 的函数类型的实参。

函数类型的参数默认值和 null 值

声明函数类型的参数的时候可以指定默认值。

fun <T> Collection<T>.joinToString(
        separator: String = ",",
        prefix: String = "",
        postfix: String = "",
        transform: (T) -> String = { it.toString() }//指定参数默认值
): String {
    val result = StringBuilder(prefix)
    for ((index, element) in this.withIndex()) {
        if (index > 0) result.append(separator)
        result.append(transform(element))
    }
    result.append(postfix)
    return result.toString()
}

或者可空函数类型：

fun <T> Collection<T>.joinToString(
        separator: String = ",",
        prefix: String = "",
        postfix: String = "",
        transform: ((T) -> String)?//可空函数类型
): String {
    val result = StringBuilder(prefix)
    for ((index, element) in this.withIndex()) {
        if (index > 0) result.append(separator)
        //调用 invoke 方法执行函数
        result.append(transform?.invoke(element) ?: element.toString())
    }
    result.append(postfix)
    return result.toString()
}

返回函数的函数

enum class Delivery { STANDARD, EXPEDITED }

class Order(val itemCount: Int)

fun getShippingCostCalculator(
        delivery: Delivery): (Order) -> Double {
    if (delivery == Delivery.EXPEDITED) {
        return { order -> 6 + 2.1 * order.itemCount }
    }
    return { order -> 1.2 * order.itemCount }
}

总结

Lambda表达式是为我们减少了大量的代码，但是Lambda表达式是为后面的高阶函数章节打下基础，虽然在这篇文章中也提到了高阶函数，但是都是最基础的，在下一节中会为大家介绍自定义高阶函数与Kotlin自身中常用的高阶函数讲解。
在这一章节中，讲述了Lambda的语法、使用。以及Lambda表达式的一些特性与实践操作。当然还包含了匿名函数这一知识点。其中最重要的当属Lambda的实践操作。如果你看完这篇文章还不甚理解，请在仔细的阅读一遍并实际代码演练，因为在后面的高阶函数章节还会遇到。

宁一城

关注

2
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
详解Kotlin中的Lambda

Kotlin中的Lambda表达式目录：1、Lambda介绍在上面已经提到了在Java中已经被广泛的运用，但是也是在Java8的时候才支持这种Lambda表达式。在其他的编程语言中（例如：Scala语言）。而这种表达式是语法糖中的一种。值得庆幸的是，Kotlin一经开源成熟就已经支持这种语法。Lambda表达式的本质其实是匿名函数，因为在其底层实现中还是通过匿名函数来实现的。但是我们在用的时候不必关心起底层实现。不过Lambda的出现确实是减少了代码量的编写，同时也是代码变得更加简洁明了。L
复制链接

扫一扫