[TOC] ## 高阶函数的使用 通过上一小节我们已经知道，Lambda表达式都是定义在方法内部，那么，在定义Lambda表达式时还可以在其他地方声明吗？答案是可以。**Lambda表达式还可以作为函数的实际参数或者返回值存在**，而这种声明，**在Kotlin中叫做高阶函数**。将Lambda表达式作为参数或返回值，会**大大地简化程序开发时的代码，提高程序开发效率**。接下来我们将针对高级函数进行详细讲解。 ### 函数作为参数使用 Lambda表达式，除了定义在方法的内部，**还可以作为函数的实参**，这种做法拓宽了我们的编程思维。 例如有一个[1,50]的区间，想要根据条件对元素进行选择，此时可以选择大于1的，可以选择大于2的，可以选择能被5整除的……，但由于选择条件很多，不可能把所有的选择条件都定义成方法，**此时最好的办法就是将Lambda表达式作为参数，在选择元素的时候指定选择条件**。接下来我们通过一个案例来演示函数作为参数的使用，具体代码如下所示。 ``` //给区间定义一个扩展方法 fun IntRange.pickNum(function: (Int) -> Boolean): List<Int> { val resultList = mutableListOf<Int>() //声明集合 for (i in this) { //this指向定义的区间(IntRange)范围1-20 if (function(i)) { //方法名(参数)指向传递过来Lambda表达式判断是否满足条件 resultList.add(i) //符合条件的数据添加到集合中 } } return resultList //将集合返回 } fun main(args: Array<String>) { //定义区间范围1-20 val list = 1..20 println("--------能被5整除的数--------") println(list.pickNum({ x: Int -> x % 5 == 0 })) println("--------能被10整除的数--------") println(list.pickNum({ x: Int -> x % 10 == 0 })) } ``` 运行结果： ``` --------能被5整除的数-------- [5, 10, 15, 20] --------能被10整除的数-------- [10, 20] ``` 在上述代码中，首先声明了一个方法IntRange.pickNum（function:（Int）-＞Boolean），将Lambda表达式当作参数传递。第4行代码中的this指向定义的区间（1..20），然后通过第5～7行代码进行判断此数字是否满足条件，如果满足条件就添加到集合中。 >[success]需要注意的是，针对“`function:（Int）-＞Boolean`”函数作为参数，需要知道以下几点。 > * function：形式参数名（**形参参数名**），可以任意修改。 > * (Int)-＞Boolean：形式参数类型（**形参数据类型**），这里描述的是一个函数类型，函数的参数是Int类型，函数的返回值是Boolean类型。 ### 函数作为参数优化 当Lambda表达式作为函数参数使用时，还有3种优化形式，这**3种优化形式分别是省略小括号、将参数移动到小括号外面、使用it关键字**，接下来我们就针对这3种优化形式进行详细的讲解。 #### 省略小括号 **如果函数只有一个参数，且这个参数类型是一个函数类型，则在调用函数时可以去掉函数名称后面的小括号**，具体代码如下所示。 ``` //给区间定义一个扩展方法 fun IntRange.pickNum(function: (Int) -> Boolean): List<Int> { val resultList = mutableListOf<Int>() for (i in this) { if (function(i)) { resultList.add(i) } } return resultList } fun main(args: Array<String>) { //定义区间 val list = 1..50 println("--------选择出能被10整除的--------") //省略之前 println(list.pickNum({ x: Int -> x % 10 == 0 })) //省略之后 println(list.pickNum { x: Int -> x % 10 == 0 }) } ``` 运行结果： ``` --------选择出能被10整除的-------- [10, 20, 30, 40, 50] [10, 20, 30, 40, 50] ``` 在上述代码中，**`pickNum（function:（Int）-＞Boolean）`函数只有一个参数，并且参数类型是函数类型，因此在调用函数时，可以省略函数名称后面的小括号，直接使用`pickNum{x:Int-＞x%10==0}`即可**。 #### 将参数移动到小括号外面 **如果一个函数有多个参数，但是最后一个参数类型是函数类型，那么在调用函数时，可以将最后一个参数从括号中移出，并且去掉参数之间的符号“,”**，具体代码如下所示。 ``` fun main(args: Array<String>) { //定义区间 val list = 1..50 println("--------选择出能被10整除的--------") //将参数从括号中移出之前 println(list.pickNum(1,{ x: Int -> x % 10 == 0 })) //将参数从括号中移出之后 println(list.pickNum(1) { x: Int -> x % 10 == 0 }) } //给区间定义一个扩展方法 fun IntRange.pickNum(need: Int, function: (Int) -> Boolean): List<Int> { val resultList = mutableListOf<Int>() for (i in this) { if (function(i)) { resultList.add(i) } } return resultList } ``` 运行结果： ``` --------选择出能被10整除的-------- [10, 20, 30, 40, 50] [10, 20, 30, 40, 50] ``` 在上述代码中，**函数pickNum()有两个参数，一个是Int类型的，另一个是函数类型的。当调用该函数时，可以将Lambda表达式`(1,{ x: Int -> x % 10 == 0 })`移动到括号之外，即`list.pickNum（1）{x:Int-＞x%10==0}`**。 #### 使用it关键字 **无论函数包含多少个参数，如果其中有参数是函数类型，并且函数类型满足只接收一个参数的要求，可以用it关键字代替函数的形参以及箭头**，具体代码如下所示。 ``` //给区间定义一个扩展方法 fun IntRange.pickNum(function: (Int) -> Boolean): List<Int> { val resultList = mutableListOf<Int>() for (i in this) { if (function(i)) { resultList.add(i) } } return resultList } fun main(args: Array<String>) { //定义区间 val list = 1..50 println("--------选择出能被10整除的--------") //使用it关键字之前 println(list.pickNum { x: Int -> x % 10 == 0 }) //使用it关键字之后 println(list.pickNum { it % 10 == 0 }) } ``` 运行结果： ``` --------选择出能被10整除的-------- [10, 20, 30, 40, 50] [10, 20, 30, 40, 50] ``` 在上述代码中，`pickNum(function: (Int) -> Boolean)`函数只有一个参数，其中“`function:（Int）-＞Boolean`”参数是函数类型并且只接收一个参数，因此在调用函数时，可以**使用it关键字代替函数形参以及箭头**，即`list.pickNum{it%10==0}`。 >[success] **总结** Kotlin与Java中的函数对比 在Kotlin中有这样一句话：“函数，在Kotlin中是一等公民”。怎么去理解这句话呢？其实可以**从放置位置和定义形式两个方面去理解**。在Java中函数定义形式就一种，放置位置都在类或者接口中。 然而在Kotlin中，从函数定义形式方面来讲，函数可以有普通的定义方式、可以用表达式函数体、可以把Lambda赋值给变量；从函数放置的位置方面来讲，函数可以放置在类的外面（顶层函数）、可以放置在方法的内部（嵌套函数）、可以作为参数传递、可以作为函数的返回值。函数的功能非常强大与灵活，并且地位大大提升，所以说Kotlin中的函数就是一等公民。 ### 函数作为返回值 函数不仅可以作为参数使用，还可以**作为返回值使用**。接下来我们通过一个普通用户与VIP用户购物的案例进行演示，具体代码如下所示。 ``` enum class USER { //声明枚举 定义两种类型 NORMAL, VIP } //声明方法 fun getPrice(userType: USER): (Double) -> Double { if (userType == USER.NORMAL) { //判断类型是否是普通类型 return { it } } return { price -> 0.88 * price } } fun main(args: Array<String>) { val normalUserPrice = getPrice(USER.NORMAL)(200.0) println("普通用户价格：$normalUserPrice") val vipPrice = getPrice(USER.VIP)(200.0) println("超级会员价格：$vipPrice") } ``` 运行结果： ``` 普通用户价格：200.0 超级会员价格：176.0 ``` 在上述代码中，首先声明一个方法`getPrice(userType: USER): (Double) -> Double`，**将Lambda表达式当作返回值使用**。 **需要注意的是**，针对`(Double) -> Double`函数作为返回值，需要注意以下几点。 * (Double)：为Lambda表达式的参数类型。 * `-> Double`：这里的Double为Lambda表达式的返回值，即当前getPrice()方法的返回值。 ### 标准库中的高阶函数 通过上一节的学习，我们会发现高阶函数相比普通函数不仅减少了代码的编写，而且使用也更加灵活，因此，**Kotlin官方提供了一些定义好的高阶函数，方便使用**。本节我们将针对标准库中的高阶函数进行详细讲解。 #### 高阶函数操作集合 在实际开发中，很多数据都会通过集合来封装，不可避免地会**有大量的集合操作**，例如常见的增删改查，复杂的排序、查找等。那么在处理这些业务逻辑时就会耗费一些时间去思考如何在最短的时间高效地完成这些集合操作。为了解决这个问题，**Kotlin标准库定义了大量的对于集合操作的函数**，在本节中我们将选取一些常用、具有代表性的函数进行讲解。 ##### 查找元素操作 Collections中提供了一些常用的方法用于查找、匹配集合中的元素，如表6-1所示。  :-: 表6-1　集合中常见的高阶函数——查找 在表6-1中，**每个方法都接收一个函数式表达式作为参数，并且Interable为集合的基类**，所以在实现的过程中可以直接通过集合对象来调用方法即可。接下来我们来通过一些案例对表中的方法进行学习。 * **（1）find()方法** find()方法**用于查找并返回指定条件的第1个元素，没有找到符合条件的元素返回NULL**。接下来我们通过一个案例进行演示，具体代码如下所示。 ``` fun main(args: Array<String>) { val list = listOf(-2, -1, 0, 1, 2) println("----------find----------") println("找出大于0的元素：${list.find { it > 0 }}") println("找出等于3的元素：${list.find { it == 3 }}") } ``` 运行结果： ``` ----------find---------- 找出大于0的元素：1 找出等于3的元素：null ``` 在上述代码中，定义了一个集合来存储5个元素，然后通过find()方法分别查找大于0与等于3的元素，在该集合中会发现元素1和元素2大于0。但是**find()方法只会返回符合条件的第一个元素，所以输出结果为1，然而集合中并没有等于3的元素，所以会返回NULL**。 * **（2）first()与last()方法** **first()方法用于查找并返回指定条件的第1个元素，last()方法用于查找并返回指定条件的最后1个元素，如果这两个方法在查找时没有找到匹配的元素，会在运行时抛出异常**。接下来我们通过一个案例进行演示，具体代码如下 ``` fun main(args: Array<String>) { val list = listOf(-2, -1, 0, 1, 2) println("----------first----------") println("大于0的元素：${list.first { it > 0 }}") println("大于0的元素：${list.last { it > 0 }}") println("等于3的元素：${list.first { it == 3 }}") } ``` 运行结果： ``` ----------first---------- 大于0的元素：1 大于0的元素：2 Exception in thread "main" java.util.NoSuchElementException: Collection contains no element matching the predicate. at FileKt.main (File.kt:23) ``` 从运行结果可以看出，在first()方法查找元素时返回的是符合条件的第1个元素1，而last()方法查找元素时返回的是符合条件的最后一个元素2。当在集合中没有找到满足指定条件的元素时会报出一个异常`java.util.NoSuchElementException`。 * **（3）single()方法** **single()方法用于在当前的集合中查找满足指定条件的一个元素**。需要注意的是，**满足条件的元素只能有一个，多个或者没有都会抛出异常**。接下来我们通过一个案例进行演示，具体代码如下所示。 ``` fun main(args: Array<String>) { val list = listOf(-2, -1, 0, 1, 2) println("大于1的元素：${list.single { it > 1 }}") println("大于-2的元素：${list.single { it > 0 }}") } ``` 运行结果： ``` 大于1的元素：2 Exception in thread "main" java.lang.IllegalArgumentException: Collection contains more than one matching element. at FileKt.main (File.kt:26) ``` 在上述代码中，第4行代码声明的条件为集合中的元素大于1，而大于1的元素只有2，所以返回结果为2。在第7行中，声明的条件为集合中的元素大于0，而大于0的元素有两个，分别为1和2，但是结果直接抛出了异常，这说明single()方法只能用于查找当前集合中符合条件的一个元素，否则会抛出异常。 * **（4）takeWhile()方法** 以上find()、first()等几个方法都是在当前的集合中查找满足条件的一个元素。那么**怎样查找多个满足条件的元素呢**？此时就需要使用**takeWhile()方法：查找并返回指定条件的列表，如果没有找到则返回一个空的列表，第一个元素必须满足条件否则不会继续查找**。接下来我们通过一个案例来演示如何使用takeWhile()方法，具体代码如下所示。 ``` fun main(args: Array<String>) { val list = listOf(-2, -1, 0, 1, 2) println("大于-3的元素：${list.takeWhile { it > -3 // 第一个需求 }}") println("大于0的元素：${list.takeWhile { it > 0 // 第二个需求 }}") println("小于0的元素：${list.takeWhile { it < 0 // 第三个需求 }}") } ``` 运行结果： ``` 大于−3的元素：[−2,−1, 0, 1, 2] 大于0的元素：[] 小于0的元素：[−2,−1] ``` 在上述代码中，声明了3个需求条件，第1个条件是查找大于-3的元素，可以看到集合中的每一个元素都大于-3，所以输出集合中所有元素。第2个需求是查找大于0的元素，通过观察集合中的元素可以发现大于0的元素有1和2，但是结果却输出了一个空的列表。这个是什么原因呢？原因就是**当调用takeWhile()方法时，匹配条件必须是第1个元素满足条件才可以继续向下查找，而在集合中第1个元素是-2，-2是小于0的，所以返回一个空的列表**。同理，第3个需求查找小于0的元素，只有-1与-2，所以输出的结果就是-1和-2。 * **（5）filter()方法** **filter()方法：查找并返回指定条件的列表，如果没有找到则返回一个空的列表，只要满足条件即可** 在通过**takeWhile()方法**进行查找时，我们发现**有一个局限性是必须满足第1个条件的情况下，才可以继续向下查找，这样会导致后面符合条件的元素无法输出**。如果想要将满足条件的所有元素都输出，则需要使用filter()方法执行查找操作。接下来我们通过一个案例进行演示，具体代码如下所示。 ``` fun main(args: Array<String>) { val list = listOf(-2, -1, 0, 1, 2) println("大于-3的元素：${list.filter { it > -3 //第一个需求 }}") println("大于0的元素：${list.filter { it > 0 //第二个需求 }}") println("小于0的元素：${list.filter { it < 0 //第三个需求 }}") } ``` 运行结果： ``` 大于−3的元素：[−2,−1, 0, 1, 2] 大于0的元素：[1, 2] 小于0的元素：[−2,−1] ``` 从运行结果可以看出，在使用filter()方法时，与takeWhile()方法比较类似，都是找到满足条件的元素以列表的形式输出，但是使用takeWhile()方法时第1个元素必须满足条件，否则结束查找，而**filter()方法是从第1个元素至最后一个元素一一查找，只要是有满足条件的元素就添加至列表中并返回**。 * **（6）count()方法** **count()方法用于查找当前集合中满足于当前条件的元素个数**，例如查找一个集合中所有大于100的元素个数。接下来我们通过使用count()方法查找集合中所有大于100的元素个数，具体代码如下所示。 ``` fun main(args: Array<String>) { val list = listOf(60, 80, 100, 120, 140) println("查找大于100的元素个数：${list.count { it > 100 }}") println("查找小于60的元素个数：${list.count { it < 60 }}") } ``` 运行结果： ``` 查找大于100的元素个数：2 查找小于60的元素个数：0 ``` 在上述代码中，定义了一个集合存储了5个元素，分别是60、80、100、120、140。其中大于100的元素有120、140，所以大于100的元素个数为2。其中没有元素小于60，所以小于60的元素个数为0。 ##### 比较元素操作 Collections中提供了一些常用的方法用于比较集合中的元素，如表6-2所示。  :-: 表6-2　集合中常见的高阶函数 在表6-2中， * maxBy()方法用于获取集合中的最大值， * minBy()方法用于获取集合中最小值， * distinctBy()方法用于去除集合中重复的元素。 接下来我们通过一个案例来学习如何在集合中查找最值和去重，具体代码如下所示。 ``` fun main(args: Array<String>) { val list = listOf(-2, 0, 0, 1, 1 ,2) println("--------查找最大值--------") println(list.maxBy { it }) println("--------查找最小值--------") println(list.minBy { it }) println("--------集合去重--------") println(list.distinctBy { it }) } ``` 运行结果： ``` --------查找最大值-------- 2 --------查找最小值-------- −2 --------集合去重-------- [−2, 0, 1, 2] ``` 从运行结果可以看出，maxBy()、minBy()方法可以正常地查找到当前集合中的最大值2和最小值-2，distinctBy()方法可以去除集合中重复的元素并输出[-2, 0, 1, 2]。 #### 标准库中的高阶函数 在上一个小节中，我们讲解了Collections中的一些高阶函数，这一小节会展示**标准库中的一些高阶函数**，如with、apply、let等，**这些函数都封装在Standard类中，因此被称为标准的高阶函数**。Standard中常用的函数如表6-3所示。  :-: 表6-3　Standard中常用的函数 * **（1）repeat()函数** **repeat()函数用于重复执行某条语句，它和循环语句非常相似，但是用起来会方便一些**。 接下来我们通过一个案例进行演示，具体代码如下所示。 ``` fun main(args: Array<String>) { println("----------第一个参数值为2时----------") repeat(2,{ println("中国") }) println("----------第一个参数值为0时----------") repeat(1){ println("中国") } println("----------第一个参数值为-1时----------") repeat(0){ println("中国") } } ``` 运行结果： ``` ----------times值为2时---------- 中国 中国 ----------times值为1时---------- 中国 ----------times值为0时---------- ``` 从运行结果可以看出，将**repeat()函数的第1个参数值声明为2时**，可以将其**第2个参数所代表的函数执行两次**。而将其第1个参数值声明为0时，没有输出结果。因此，在使用repeat()函数时如果要确保能够输出结果，第1个参数值要大于0。 * **（2）T.run()函数** **T.run()函数：调用指定的函数块，用this代表函数块中当前的引用对象，并且调用函数块中的方法时，this可省略。该函数的返回值是函数块中的最后一行语句的值或return表达式的值。** `T.run(block:T.()-> R):R` 在讲解run()函数之前，让我们首先回顾一下ArrayList集合添加数据的操作，具体代码如下所示。 ``` fun main(args: Array<String>) { val list = ArrayList<Int>() list.add(1) list.add(2) list.add(3) println(list) } ``` 运行结果： ``` [1, 2, 3] ``` 在上述代码中，第3～5行代码是为ArrayList集合添加数据的，每次都需要调用list集合中的add()方法，此时list对象的类型是指定的ArrayList类型。**如果每次都通过调用add()方法来添加数据到集合中，会显得程序比较臃肿，因此为了解决这个问题，可以通过调用run()函数来实现向ArrayList集合中添加数据**，具体代码如下所示。 ``` fun main(args: Array<String>) { val list = ArrayList<String>() list.run { list.add("土星") this.add("天王星") add("海王星") add("火星") } println(list) // 输出集合里的数据 } ``` 运行结果： ``` [土星，天王星，海王星] ``` 在上述代码中，**通过run()函数为ArrayList集合添加数据，此时可以省略当前的list对象，如果使用this关键字来代替list对象调用add()方法，则此时可以省略this关键字**。这样的操作相对于之前的添加看起来会更加简洁、明确。 ArrayList集合在添加数据时会有一个返回值，当添加数据成功时，该返回值为true。那么在run()函数中给ArrayList集合添加数据时，该函数的返回值是如何来确定的呢？ 接下来我们通过一个案例来演示run()函数的返回值，具体代码如下所示。 ``` fun main(args: Array<String>) { val list = ArrayList<String>() val value = list.run { add("金星") size } println("返回值：$value") println("集合数据：$list") } ``` 运行结果： ``` 返回值：1 集合数据：[金星] ``` 从运行结果可以看出，调用run()函数时**返回值为函数体的最后一条语句，和普通的Lambda表达式是一样的**。但是**在run()函数中是可以使用return来结束当前语句的**。 接下来我们通过return来结束run()函数，具体代码如下所示。 ``` fun main(args: Array<String>) { val list = ArrayList<String>() val value = list.run { add("金星") // 添加数据 println("集合数据：$list") return size // 集合的长度 } println("返回值是：$value") println("集合数据：$list") } ``` 运行结果： ``` 集合数据：[金星] ``` 在上述代码中，第5行代码的内容可以打印输出，而第9、10行的内容没有打印输出，**没有打印输出的原因是由于在第5行使用了return语句，return语句在程序中使用时，会直接结束当前的方法以及方法外部的内容**。 现在可以得知，使用return语句时会直接结束run()函数外部的方法，也就是前面示例中的main()方法，这样**直接结束main()显然是不符合当前代码的业务逻辑的，因为在9、10行还有输出逻辑要操作**，那么如何来解决这一个问题呢？接下来我们通过一个案例**解决return语句直接结束外部方法的问题**，具体代码如下所示。 ``` fun main(args: Array<String>) { val list = ArrayList<String>() val value = list.run { add("金星") // 添加数据 println("集合数据：$list") return@run size // 集合的长度 add("火星") println("集合数据：$list") } println("返回值是：$value") println("集合数据：$list") } ``` 运行结果： ``` 集合数据：[金星] 返回值是：1 集合数据：[金星] ``` 在上述代码中，**通过使用`return@run`可以结束当前的run()函数，并且不会结束main()方法，这样就解决了使用return直接结束main()方法的问题**。此处需要注意，**结束run()方法使用“return@run”是固定格式，中间不需要空格分开，并且所有在Standard类中的方法都可以通过“return@方法名”这种格式结束当前方法**。