Kotlin系列六：从集合谈Kotlin中的Lambda编程

目录

 

一 集合的函数式API

1.1.1 List

1.1.2 Set

1.1.3 Map

二 集合的函数式API

2.1 集合的函数式API的推导

2.1 集合常用函数式API

2.1.1 map函数

2.1.2 filter函数

2.1.3 any和all函数

三 Java函数式API的使用

---

一 集合的函数式API

集合的函数式API是学习Lambda编程的绝佳示例。

传统意义上的集合主要就是List和Set，再广泛一点的话，像Map这样的键值对数据结构也可以包含进来。

List、Set和Map在Java中都是接口，List的主要实现类是ArrayList和LinkedList，Set的主要实现类是HashSet，Map的主要实现类是HashMap。

1.1 List

ArrayList的Java思维的Kotlin写法：

val list = ArrayList<String>()
list.add("Apple")
list.add("Banana")
list.add("Orange")
list.add("Pear")
list.add("Grape")

这方式较烦琐，Kotlin写法：

val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape")

for-in循环不仅可以用来遍历区间，还可以用来遍历集合：

fun main() {
    val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape")
    for (fruit in list) {
        println(fruit)
    }
}

注意：listOf()函数创建的是一个不可变的集合。

不可变的集合指的就是该集合只能用于读取，我们无法对集合进行添加、修改或删除操作。Kotlin在不可变性方面控制得极其严格。创建可变的集合用mutableListOf()函数：

fun main() {
    val list = mutableListOf("Apple", "Banana", "Orange", "Pear", "Grape")
    list.add("Watermelon")
    for (fruit in list) {
        println(fruit)
    }
}

1.2 Set

Set集合的用法和List的类似，只是将创建集合的方式换成了setOf()和mutableSetOf()函数而已。

val set = setOf("Apple", "Banana", "Orange", "Pear", "Grape")
for (fruit in set) {
    println(fruit)
}

需要注意，Set集合底层是使用hash映射机制来存放数据的，因此集合中的元素无法保证有序，这是和List集合最大的不同之处。

1.3 Map

Map是一种键值对形式的数据结构，因此在用法上和List、Set集合有较大的不同。传统的Map用法是先创建一个HashMap的实例，然后将一个个键值对数据添加到Map中。

HashMap的Java思维的Kotlin写法：

val map = HashMap<String, Int>()
map.put("Apple", 1)
map.put("Banana", 2)
map.put("Orange", 3)
map.put("Pear", 4)
map.put("Grape", 5)

在Kotlin中并不建议使用put()和get()方法来对Map进行添加和读取数据操作，而是更加推荐使用一种类似于数组下标的语法结构：

val map = HashMap<String, Int>()
map["Apple"] = 1
map["Banana"] = 2
map["Orange"] = 3
map["Pear"] = 4
map["Grape"] = 5

最方便的是，类似List和Set，Kotlin也提供了mapOf()和mutableMapOf()函数。

val map = mapOf("Apple" to 1, "Banana" to 2, "Orange" to 3, "Pear" to 4, "Grape" to 5)

这里的键值对组合看上去好像是使用to这个关键字来进行关联的，但其实to并不是关键字，而是一个infix函数。

如何遍历Map集合中的数据：

fun main() {
    val map = mapOf("Apple" to 1, "Banana" to 2, "Orange" to 3, "Pear" to 4, "Grape" to 5)
    for ((fruit, number) in map) {
        println("fruit is " + fruit + ", number is " + number)
    }
}

---

二 集合的函数式API

2.1 集合的函数式API的推导

集合的函数式API有很多个，我们重点学习函数式API的语法结构，也就是Lambda表达式的语法结构。

如何在一个水果集合里面找到单词最长的那个水果？

val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")
var maxLengthFruit = ""
for (fruit in list) {
    if (fruit.length > maxLengthFruit.length) {
        maxLengthFruit = fruit
    }
}
println("max length fruit is " + maxLengthFruit)

这段代码很简洁，但如果我们使用集合的函数式API，就可以让这个功能变得更加容易：

val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")
val maxLengthFruit = list.maxBy { it.length }
println("max length fruit is " + maxLengthFruit)

Lambda的定义：Lambda就是一小段可以作为参数传递的代码。

正常情况下，我们向某个函数传参时只能传入变量，而借助Lambda却允许传入一小段代码。到底多少代码才算一小段代码呢？Kotlin对此并没有进行限制，但是通常不建议在Lambda表达式中编写太长的代码，否则可能会影响代码的可读性。

接着我们来看一下Lambda表达式的语法结构：

{参数名1: 参数类型, 参数名2: 参数类型 -> 函数体}

这是Lambda表达式最完整的语法结构定义。首先最外层是一对大括号，如果有参数传入到Lambda表达式中的话，我们还需要声明参数列表，参数列表的结尾使用一个->符号，表示参数列表的结束以及函数体的开始，函数体中可以编写任意行代码（虽然不建议编写太长的代码），并且最后一行代码会自动作为Lambda表达式的返回值。

回到刚才找出最长单词水果的需求，前面使用的函数式API的语法结构看上去好像很特殊，但其实maxBy就是一个普通的函数而已，只不过它接收的是一个Lambda类型的参数，并且会在遍历集合时将每次遍历的值作为参数传递给Lambda表达式。maxBy函数的工作原理是根据我们传入的条件来遍历集合，从而找到该条件下的最大值，比如说想要找到单词最长的水果，那么条件自然就应该是单词的长度了。

理解了maxBy函数的工作原理之后，我们就可以开始套用刚才学习的Lambda表达式的语法结构，并将它传入到maxBy函数中了，如下所示：

val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")
val lambda = { fruit: String -> fruit.length }
val maxLengthFruit = list.maxBy(lambda)

可以看到，maxBy函数实质上就是接收了一个Lambda参数而已，并且这个Lambda参数是完全按照刚才学习的表达式的语法结构来定义的，因此这段代码应该算是比较好懂的。

这种写法虽然可以正常工作，但是比较啰嗦，可简化的点也非常多，下面我们就开始对这段代码一步步进行简化。

首先，我们不需要专门定义一个lambda变量，而是可以直接将lambda表达式传入maxBy函数当中，因此第一步简化如下所示：

val maxLengthFruit = list.maxBy({ fruit: String -> fruit.length })

然后Kotlin规定，当Lambda参数是函数的最后一个参数时，可以将Lambda表达式移到函数括号的外面，如下所示：

val maxLengthFruit = list.maxBy() { fruit: String -> fruit.length }

接下来，如果Lambda参数是函数的唯一一个参数的话，还可以将函数的括号省略：

val maxLengthFruit = list.maxBy { fruit: String -> fruit.length }

这样代码看起来就变得清爽多了吧？但是我们还可以继续进行简化。由于Kotlin拥有出色的类型推导机制，Lambda表达式中的参数列表其实在大多数情况下不必声明参数类型，因此代码可以进一步简化成：

val maxLengthFruit = list.maxBy { fruit -> fruit.length }

最后，当Lambda表达式的参数列表中只有一个参数时，也不必声明参数名，而是可以使用it关键字来代替，那么代码就变成了：

val maxLengthFruit = list.maxBy { it.length }

通过一步步推导的方式，我们就得到了和一开始那段函数式API一模一样的写法。

2.1 集合常用函数式API

2.1.1 map函数

map函数是最常用的一种函数式API，它用于将集合中的每个元素都映射成一个另外的值，映射的规则在Lambda表达式中指定，最终生成一个新的集合。比如，这里我们希望让所有的水果名都变成大写模式，就可以这样写：

fun main() {
    val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")
    val newList = list.map { it.toUpperCase() }
    for (fruit in newList) {
        println(fruit)
    }
}

map函数的功能非常强大，它可以按照我们的需求对集合中的元素进行任意的映射转换，上面只是一个简单的示例而已。除此之外，你还可以将水果名全部转换成小写，或者是只取单词的首字母，甚至是转换成单词长度这样一个数字集合，只要在Lambda表示式中编写你需要的逻辑即可。

2.1.2 filter函数

filter函数是用来过滤集合中的数据的，它可以单独使用，也可以配合刚才的map函数一起使用。

比如我们只想保留5个字母以内的水果，就可以借助filter函数来实现，代码如下所示：

fun main() {
    val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")
    val newList = list.filter { it.length <= 5 }
                      .map { it.toUpperCase() }
    for (fruit in newList) {
        println(fruit)
    }
}

可以看到，这里同时使用了filter和map函数，并通过Lambda表示式将水果单词长度限制在5个字母以内。

另外值得一提的是，上述代码中我们是先调用了filter函数再调用map函数。如果你改成先调用map函数再调用filter函数，也能实现同样的效果，但是效率就会差很多，因为这样相当于要对集合中所有的元素都进行一次映射转换后再进行过滤，这是完全不必要的。而先进行过滤操作，再对过滤后的元素进行映射转换，就会明显高效得多。

2.1.3 any和all函数

any函数用于判断集合中是否至少存在一个元素满足指定条件，all函数用于判断集合中是否所有元素都满足指定条件。

fun main() {
    val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")
    val anyResult = list.any { it.length <= 5 }
    val allResult = list.all { it.length <= 5 }
    println("anyResult is " + anyResult + ", allResult is " + allResult)
}

这里还是在Lambda表达式中将条件设置为5个字母以内的单词，那么any函数就表示集合中是否存在5个字母以内的单词，而all函数就表示集合中是否所有单词都在5个字母以内。现在重新运行一下代码：

---

三 Java函数式API的使用

Kotlin中调用Java方法时也可以使用函数式API，只不过这是有一定条件限制的。具体来讲，如果我们在Kotlin代码中调用了一个Java方法，并且该方法接收一个Java单抽象方法接口参数，就可以使用函数式API。Java单抽象方法接口指的是接口中只有一个待实现方法，如果接口中有多个待实现方法，则无法使用函数式API。

Java中子线程的例子：

public interface Runnable {
    void run();
}

new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Thread is running");
    }
}).start();

Kotlin原始版本写法：

Thread(object : Runnable {
    override fun run() {
        println("Thread is running")
    }
}).start()

目前Thread类的构造方法是符合Java函数式API的使用条件的，初步精简：

Thread(Runnable {
    println("Thread is running") 
}).start()

如果一个Java方法的参数列表中不存在一个以上Java单抽象方法接口参数，我们还可以将接口名进行省略，再次精简：

Thread({
    println("Thread is running") 
}).start()

Kotlin中当Lambda表达式是方法的最后一个参数时，可以将Lambda表达式移到方法括号的外面。同时，如果Lambda表达式还是方法的唯一一个参数，还可以将方法的括号省略，最终精简结果：

Thread {
    println("Thread is running")
}.start()

或许你会觉得，既然本书中所有的代码都是使用Kotlin编写的，这种Java函数式API应该并不常用吧？其实并不是这样的，因为我们后面要经常打交道的Android SDK还是使用Java语言编写的，当我们在Kotlin中调用这些SDK接口时，就很可能会用到这种Java函数式API的写法。

举个例子，Android中有一个极为常用的点击事件接口OnClickListener，其定义如下：

public interface OnClickListener {
    void onClick(View v);
}

可以看到，这又是一个单抽象方法接口。假设现在我们拥有一个按钮button的实例，然后使用Java代码去注册这个按钮的点击事件，需要这么写：

button.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
    }
});

而用Kotlin代码实现同样的功能，就可以使用函数式API的写法来对代码进行简化，结果如下：

button.setOnClickListener {
}

可以看到，使用这种写法，代码明显精简了很多。这段给按钮注册点击事件的代码，我们在正式开始学习Android程序开发之后将会经常用到。

学习参考

1 官网文档 基本语法 - Kotlin 语言中文站

2 郭霖：《第一行代码》