Kotlin基础——Lambda和函数式编程

Lambda

使用 { } 定义Lamba，调用run运行

run { println(1) }

更常用的为 { 参数 -> 操作 }，还可以存储到变量中，把变量作为普通函数对待，若返回的不是Unit则最后一行表达式的值类型就是返回值类型

val sum: (Int, Int) -> Int = { x: Int, y: Int -> x + y }
val sum2: (Int, Int) -> Int = { x, y -> x + y }
val sum3 = { x: Int, y: Int -> x + y }
println(sum(1, 2))

maxBy()接收一个Lambda，传递如下

class Person(val name: String, val age: Int)
val people = listOf(Person("A", 18), Person("B", 19))

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

println(people.maxBy { p: Person -> p.age })	//只有一个参数，可省略()
println(people.maxBy() { p -> p.age })		//可推导出类型
println(people.maxBy() { it.age })		//只有一个参数且可推导出类型，会自动生成it

Lambda可使用函数参数和局部变量

 fun printProblemCounts(response: Collection<String>) {
     var clientErrors = 0
     var serverErrors = 0
     response.forEach {
         if (it.startsWith("4")) {
             clientErrors++
         } else if (it.startsWith("5")) {
             serverErrors++
         }
     }
 }

Lambda和函数区别

fun + {} 为代码块函数体

fun foo(x: Int, y: Int):Int {
    return x + y
}
foo(1,2)

fun + = 为表达式函数体

fun foo(x: Int, y: Int) = x + y
foo(1,2)

var + = + {}为Lambda表达式

val foo = { x: Int, y: Int -> x + y }
foo.invoke(1, 2)
foo(1, 2)

fun + = + {} 为Lambda表达式函数体

fun foo(x: Int) = { y: Int ->
    x + y
}
foo(1).invoke(2)
foo(1)(2)

成员引用

上面通过Lambda将代码块作为参数传递给函数，若要传递代码块已被封装成函数，则需要传递一个调用该函数的Lambda，如下计算虚岁

class Person(val name: String, val age: Int) {
    fun getNominalAge(): Int {
        return age + 1
    }
}

val people = listOf(Person("A", 18), Person("B", 19))
println(people.maxBy { p: Person -> p.getNominalAge() })

println(people.maxBy(Person::getNominalAge))		//成员引用，可以省略多余的函数调用

上面是系统为fun getNominalAge()自动生成的成员引用，实际定义应该如下，把函数转换为一个值，从而可以传递它

• 把函数age + 1传递给getNominalAge，通过Person::getNominalAge引用函数
• 直接通过Person::age引用成员

 class Person(val name: String, val age: Int) {
     val getNominalAge = age + 1
 }
 
 val people = listOf(Person("A", 18), Person("B", 19))
 println(people.maxBy(Person::getNominalAge))
 println(people.maxBy(Person::age))

若引用顶层函数，则可以省略类名称，以::开头

fun salute() = println("Salute")

run(::salute)

集合的函数式API

filter和map

filter遍历集合并筛选指定Lambda返回true的元素，如下遍历偶数

val list = listOf(1, 2, 3, 4)
println(list.filter { it % 2 == 0 })

data class Person(val name: String, val age: Int)
val people = listOf(Person("A", 29), Person("B", 31))
println(people.filter { it.age > 30 })

map对集合中的每一个元素应用给定的函数并把结果收集到一个新的集合

val list = listOf(1, 2, 3, 4)
println(list.map { it * it })

data class Person(val name: String, val age: Int)
val people = listOf(Person("A", 29), Person("B", 31))
println(people.map(Person::name))

Lambda会隐藏底层操作，如寻找最大年龄，若集合大小为100，第一种方式会执行100遍，应该避免

data class Person(val name: String, val age: Int)
val people = listOf(Person("A", 29), Person("B", 31))
people.filter { it.age == people.maxBy(Person::age)!!.age }

val maxAge = people.maxBy(Person::age)!!.age
people.filter { it.age == maxAge }

对于Map，可调用filterKeys/mapKeys、filterValues/mapValues

val numbers = mapOf(0 to "zero", 1 to "one")
println(numbers.mapValues { it.value.toUpperCase() })

all、any、count、find

all判断集合所有元素是否都满足条件，any判断至少存在一个满足条件的元素

data class Person(val name: String, val age: Int)
val people = listOf(Person("A", 26), Person("B", 27))

val max27 = { p: Person -> p.age >= 27 }
println(people.all(max27))
println(people.any(max27))

!all()表示不是所有符合条件，可用any对条件取反来代替，后者更容易理解

val list = listOf(1, 2, 3)
println(!list.all { it == 3 })
println(list.any { it != 3 })

count用于获取满足条件元素的个数，其通过跟踪匹配元素的数量，不关心元素本身，更加高效，若使用size则会创建临时集合存储所有满足条件的元素

data class Person(val name: String, val age: Int)
val people = listOf(Person("A", 26), Person("B", 27))
val max27 = { p: Person -> p.age >= 27 }

println(people.count(max27))
println(people.filter(max27).size)

find找到一个满足条件的元素，若有多个则返回第一个，否则返回null，同义函数firstOrNull

data class Person(val name: String, val age: Int)
val people = listOf(Person("A", 26), Person("B", 27))
val max27 = { p: Person -> p.age >= 27 }

println(people.find(max27))
println(people.firstOrNull(max27))

groupby

groupby把列表转成分组的map

data class Person(val name: String, val age: Int)

val people = listOf(Person("A", 26), Person("B", 27), Person("C", 27))
println(people.groupBy { it.age })

如上打印

{
26=[Person(name=A, age=26)], 
27=[Person(name=B, age=27), Person(name=C, age=27)]
}

flatMap、flatten

flatMap根据给定的函数对集合中的每个元素做映射，然后将集合合并，如下打印 [A, 1, B, 2, C, 3]

val strings = listOf("A1", "B2", "C3")
println(strings.flatMap { it.toList() })

如统计图书馆书籍的所有作者，使用Set去除重复元素

data class Book(val title: String, val authors: List<String>)
val books = listOf(
    Book("A", listOf("Tom")),
    Book("B", listOf("john")),
    Book("C", listOf("Tom", "john"))
)
println(books.flatMap { it.authors }.toSet())

flatten用于合并集合，如下打印 [A1, B2, C3]

val strings = listOf("A1", "B2", "C3")
println(listOf(strings).flatten())

序列

序列的好处

map / filter 会创建临时的中间集合，如下就创建了2个

data class Person(val name: String, val age: Int)
val people = listOf(Person("A", 26), Person("B", 27))
println(people.map(Person::age).filter { it > 26 })

而使用序列可以避免创建

println(people.asSequence()
    .map(Person::age)
    .filter { it > 26 }
    .toList())

惰性操作及性能

序列的中间操作都是惰性的，如下不会有输出

listOf(1, 2, 3, 4).asSequence()
    .map { println("map($it)"); it * it }
    .filter { println("filter($it)");it % 2 == 0 }

只有当末端操作时才会被调用，如toList()

listOf(1, 2, 3, 4).asSequence()
    .map { println("map($it)"); it * it }
    .filter { println("filter($it)");it % 2 == 0 }
    .toList()

• 序列先处理第一个元素，然后再处理第二个元素，故可能有些元素不会被处理，或轮到它们之前就已经返回
• 若不使用序列，则会先求出map的中间集合，对其调用find

println(listOf(1, 2, 3, 4).asSequence().map { print(" map($it)");it * it }.find { it > 3 })
println(listOf(1, 2, 3, 4).map { print(" map($it)");it * it }.find { it > 3 })

如上都打印4，但序列运行到第二个时已找到满足条件，后面不会再执行

map(1) map(2)4
map(1) map(2) map(3) map(4)4

序列的顺序也会影响性能，第二种方式先filter再map，所执行的变换次数更少

data class Person(val name: String, val age: Int)
val people = listOf(Person("A", 26), Person("AB", 27), Person("ABC", 26), Person("AB", 27))

println(people.asSequence().map(Person::name).filter { it.length < 2 }.toList())

println(people.asSequence().filter { it.name.length < 2 }.map(Person::name).toList())

创建序列

generateSequence根据前一个元素计算下一个元素

val naturalNumbers = generateSequence(0) { it + 1 }
val numbersTo100 = naturalNumbers.takeWhile { it <= 100 }
println(numbersTo100.sum())

Sequence和Java的Stream区别

• Sequence和Stream都是惰性的
• Stream是一次性的，只能遍历一次
• Stream能够并行处理数据

和Java一起使用

函数式接口（SAM接口）

若存在如下Java函数

public class Test {
    public static void run(int delay, Runnable runnable) {
        try {
            Thread.sleep(delay);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        runnable.run();
    }
}

对于上面接受Runnable的接口，可以传递Lambda或创建实例，前者不会创建新的实例，后者每次都会创建

Test.run(1000, Runnable { println("Kotlin") })
Test.run(1000, { println("Kotlin") })
Test.run(1000) { println("Kotlin") }    //最优

Test.run(1000, object : Runnable {
    override fun run() {
        println("Kotlin")
    }
})

若Lambda捕捉到了变量，每次调用会创建一个新对象，存储被捕捉变量的值

• 若捕捉了变量，则Lambda会被编译成一个匿名类，否则编译成单例
• 若将Lambda传递给inline函数，则不会创建任何匿名类

fun handleRun(msg: String) {
    Test.run(1000) { println(msg) }
}

SAM构造方法

大多数情况下，Lambda到函数式接口实例的转换都是自动的，但有时候也需要显示转换，即使用SAM构造方法，其名称和函数式接口一样，接收一个用于函数式接口的Lambda，并返回这个函数式接口的实例

val runnable = Runnable { println("Kotlin") }   //SAM

runnable.run()

如下使用SAM构造方法简化监听事件

val listener = View.OnClickListener { view ->
    val text = when (view.id) {
        1 -> "1"
        else -> "-1"
    }
    println(text)
}

带接收者的Lambda

with

fun alphabet(): String {
    val result = StringBuilder()
    for (letter in 'A'..'Z') {
        result.append(letter)
    }
    result.append("\nover")
    return result.toString()
}

上面代码多次重复result这个名称，使用with可以简化，内部可用this调用方法或省略

• with接收两个参数，下面例子参数为StringBuilder和Lambda，但把Lambda放在外面
• with把第一个参数转换成第二个参数Lambda的接收者

fun alphabet(): String {
    val result = StringBuilder()
    return with(result) {
        for (letter in 'A'..'Z') {
            this.append(letter)
        }
        append("\nover")
        toString()
    }
}

还可以进一步优化

fun alphabet() = with(StringBuilder()) {
    for (letter in 'A'..'Z') {
        this.append(letter)
    }
    append("\nover")
    toString()
}

apply

with返回执行Lambda的结果，而apply()返回接收者对象，可以对任意对象上使用来创建对象实例

fun alphabet() = StringBuilder().apply {
    for (letter in 'A'..'Z') {
        this.append(letter)
    }
    append("\nover")
}.toString()

使用库函数buildString还可以简化上述操作

fun alphabet() = buildString {
    for (letter in 'A'..'Z') {
        this.append(letter)
    }
    append("\nover")
}