阅读 456

kotlin lambda表达式

1. 函数

1.1 函数声明

Kotlin 中的函数使用 fun 关键字声明:

fun double(x: Int): Int {
    return 2 * x
}
复制代码

1.2 函数用法

调用函数使用传统的方法:

val result = double(2)
复制代码

调用成员函数使用点表示法:

Stream().read() // 创建类 Stream 实例并调用 read()
复制代码

1.3参数

函数参数使用 Pascal 表示法定义,即 name: type。参数用逗号隔开。 每个参数必须有显式类型:

fun powerOf(number: Int, exponent: Int): Int { /*……*/ }
复制代码

You can use a trailing comma when you declare function parameters:

fun powerOf(
    number: Int,
    exponent: Int, // trailing comma
) { /*...*/ }
复制代码

1.4 返回 Unit 的函数

如果一个函数不返回任何有用的值,它的返回类型是 UnitUnit 是一种只有一个值——Unit 的类型。这个值不需要显式返回:

fun printHello(name: String?): Unit {
    if (name != null)
        println("Hello $name")
    else
        println("Hi there!")
    // `return Unit` 或者 `return` 是可选的
}
复制代码

Unit 返回类型声明也是可选的。上面的代码等同于:

fun printHello(name: String?) { …… }
复制代码

1.5 单表达式函数

当函数返回单个表达式时,可以省略花括号并且在 = 符号之后指定代码体即可:

fun double(x: Int): Int = x * 2
复制代码

当返回值类型可由编译器推断时,显式声明返回类型是可选的:

fun double(x: Int) = x * 2
复制代码

2. 高阶函数与 lambda 表达式

​ Kotlin 函数都是头等的,这意味着它们可以存储在变量与数据结构中、作为参数传递给其他高阶函数以及从其他高阶函数返回。可以像操作任何其他非函数值一样操作函数。

2.1 高阶函数

​ 高阶函数是将函数用作参数或返回值的函数。一个不错的示例是集合的函数式风格的 fold, 它接受一个初始累积值与一个接合函数,并通过将当前累积值与每个集合元素连续接合起来代入累积值来构建返回值:

fun <T, R> Collection<T>.fold(
    initial: R, 
    combine: (acc: R, nextElement: T) -> R
): R {
    var accumulator: R = initial
    for (element: T in this) {
        accumulator = combine(accumulator, element)
    }
    return accumulator
}
复制代码

​ 在上述代码中,参数 combine 具有函数类型 (R, T) -> R,因此 fold 接受一个函数作为参数, 该函数接受类型分别为 RT 的两个参数并返回一个 R 类型的值。 在 for-循环内部调用该函数,然后将其返回值赋值给 accumulator。为了调用 fold,需要传给它一个函数类型的实例作为参数,而在高阶函数调用处,(下文详述的)lambda 表达 式广泛用于此目的。

​ 为了调用 fold,需要传给它一个函数类型的实例作为参数,而在高阶函数调用处,(下文详述的)lambda 表达 式广泛用于此目的。

val items = listOf(1, 2, 3, 4, 5)

// Lambdas 表达式是花括号括起来的代码块。
items.fold(0, { 
    // 如果一个 lambda 表达式有参数,前面是参数,后跟“->”
    acc: Int, i: Int -> 
    print("acc = $acc, i = $i, ") 
    val result = acc + i
    println("result = $result")
    // lambda 表达式中的最后一个表达式是返回值:
    result
})

// lambda 表达式的参数类型是可选的,如果能够推断出来的话:
val joinedToString = items.fold("Elements:", { acc, i -> acc + " " + i })

// 函数引用也可以用于高阶函数调用:
val product = items.fold(1, Int::times)

复制代码

2.2 函数类型

Kotlin 使用类似 (Int) -> String 的一系列函数类型来处理函数的声明: val onClick: () -> Unit = ……

这些类型具有与函数签名相对应的特殊表示法,即它们的参数和返回值:

  • 所有函数类型都有一个圆括号括起来的参数类型列表以及一个返回类型:(A, B) -> C 表示接受类型分别为 AB 两个参数并返回一个 C 类型值的函数类型。 参数类型列表可以为空,如 () -> AUnit 返回类型不可省略。
  • 函数类型可以有一个额外的接收者类型,它在表示法中的点之前指定: 类型 A.(B) -> C 表示可以在 A 的接收者对象上以一个 B 类型参数来调用并返回一个 C 类型值的函数。 带有接收者的函数字面值通常与这些类型一起使用。
  • 挂起函数属于特殊种类的函数类型,它的表示法中有一个 suspend 修饰符 ,例如 suspend () -> Unit 或者 suspend A.(B) -> C

函数类型表示法可以选择性地包含函数的参数名:(x: Int, y: Int) -> Point。 这些名称可用于表明参数的含义。

如需将函数类型指定为可空,请使用圆括号:((Int, Int) -> Int)?

函数类型可以使用圆括号进行接合:(Int) -> ((Int) -> Unit)

箭头表示法是右结合的,(Int) -> (Int) -> Unit 与前述示例等价,但不等于 ((Int) -> (Int)) -> Unit

还可以通过使用类型别名给函数类型起一个别称:

typealias ClickHandler = (Button, ClickEvent) -> Unit
复制代码

2.3 函数类型实例化

有几种方法可以获得函数类型的实例:

  • 使用函数字面值的代码块,采用以下形式之一:

    带有接收者的函数字面值可用作带有接收者的函数类型的值。

  • 使用已有声明的可调用引用

    • 顶层、局部、成员、扩展函数::isOddString::toInt
    • 顶层、成员、扩展属性List<Int>::size
    • 构造函数::Regex
  • 使用实现函数类型接口的自定义类的实例:

    class IntTransformer: (Int) -> Int {
        override operator fun invoke(x: Int): Int = TODO()
    }
    
    val intFunction: (Int) -> Int = IntTransformer()
    复制代码

    如果有足够信息,编译器可以推断变量的函数类型:

    val a = { i: Int -> i + 1 } // 推断出的类型是 (Int) -> Int

  • 带与不带接收者的函数类型非字面值可以互换,其中接收者可以替代第一个参数,反之亦然。例如,(A, B) -> C 类型的值可以传给或赋值给期待 A.(B) -> C 的地方,反之亦然:

带与不带接收者的函数类型非字面值可以互换,其中接收者可以替代第一个参数,反之亦然。例如,(A, B) -> C 类型的值可以传给或赋值给期待 A.(B) -> C 的地方,反之亦然:

val repeatFun: String.(Int) -> String = { times -> this.repeat(times) }
val twoParameters: (String, Int) -> String = repeatFun // OK

fun runTransformation(f: (String, Int) -> String): String {
    return f("hello", 3)
}
val result = runTransformation(repeatFun) // OK

复制代码

请注意,默认情况下推断出的是没有接收者的函数类型,即使变量是通过扩展函数引用来初始化的。 如需改变这点,请显式指定变量类型。

2.4 Lambda 表达式与匿名函数

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.4.1 Lambda 表达式与匿名函数

lambda 表达式与匿名函数是“函数字面值”,即未声明的函数, 但立即做为表达式传递。考虑下面的例子:

max(strings, { a, b -> a.length < b.length })
复制代码

函数 max 是一个高阶函数,它接受一个函数作为第二个参数。 其第二个参数是一个表达式,它本身是一个函数,即函数字面值,它等价于以下具名函数:

fun compare(a: String, b: String): Boolean = a.length < b.length
复制代码

2.5 object是Kotlin中的一个重要的关键字,也是Java中没有的。

object是Kotlin中的一个重要的关键字,也是Java中没有的。object主要有以下三种使用场景:

  • 对象声明(Object Declaration)
  • 伴生对象(Companion Object)
  • 对象表达式(Object Expression)

2.5.1 对象声明(Object Declaration)

  1. 语法含义:将类的声明和定义该类的单例对象结合在一起(即通过object就实现了单例模式) 2) 基本示例

object RepositoryManager{ fun method(){ println("I'm in object declaration") } } 即将class关键字替换为object关键字,来声明一个类,与此同时也声明它的一个对象。只要编写这么多代码,这个类就已经是单例的了。

代码测试验证:fun main(args: Array) { RepositoryManager.method() }

2.5.2 伴生对象(Companion object)

在Kotlin中是没有static关键字的,也就是意味着没有了静态方法和静态成员。那么在kotlin中如果要想表示这种概念,取而代之的是包级别函数(package-level function)和我们这里提到的伴生对象。

class A{ companion object 伴生对象名(可以省略){ //define method and field here } }

2.5.3 对象表达式(Object Expression)

该对象表达式,实现的就是java中匿名内部类的功能。

b. 一个匿名内部类肯定是实现了一个接口或者是继承一个类,并且只能是一个,用数学术语说是“有且只有一个”

  1. 语法形式:

object [ : 接口1,接口2,类型1, 类型2]{} //中括号中的可省略

  1. 使用示例:

a. 实现一个接口或类

interface AA { fun a() }

fun main(args: Array<String>) {
val aa = object : AA {
    override fun a() {
        println("a invoked")
    }
}
​
aa.a()
}
复制代码

b. 实现多个接口和类

fun main(args: Array<String>) {
    val cc = object : AA, BB() {
        override fun a() {
​
  }
​
    override fun b() {
​
    }
​
}
​
cc.a()
cc.b()
​
}
复制代码

\

文章分类
Android
文章标签