Kotlin学习系列——函数式编程

冷不防 2023-06-28 09:56 21阅读 0赞

## 一、什么是Kotlin？ ##

Kotlin是一门新兴的Jvm语言，与Scala等充满野心，想要取代Java的Jvm语言不同，Kotlin更像是Java的扩展，它能很好的和已有的Java代码一起工作，而比起Java，Kotlin提供了许多能够大幅提高开发效率的特性，使用Kotlin能写出比Java表现力更强，且更安全的代码。并且，Kotlin对函数式编程提供了比Java8更好的支持。  
就在今年，Google宣布使用Kotlin作为安卓端的第二门官方编程语言，可以说，依托于巨大的安卓市场，Kotlin的前景是十分广阔的。

## 二、什么是函数式编程？ ##

函数式编程是不同于过程式编程的另一种编程范式（现在流行的面向对象编程，实际上是过程式编程的一种编程思想）。函数式编程的思想在许多方面和过程式是冲突的，比如，过程式编程倾向于描述“怎么做”，而函数式编程则更倾向于描述“做什么”，过程式倾向于使用变量，而函数式则倾向于使用常量。尽管如此，函数式和过程式依旧是可以共存的。  
相比过程式编程，函数式编程具有许多优势，比如：  
· 代码更简洁  
· 代码更容易推理  
· 代码可复用性更强，API更灵活  
· 函数式在编写多线程程序时更加容易  
当然，相对的，函数式编程也具有一些缺点：  
· 效率相对过程式较低  
· 对于没有接触过函数式编程的程序员，函数式的代码就像文言文一样晦涩难懂  
下面通过一个简单的例子：列表求和来比较一下过程式编程和函数式编程：  
*（实际上，Kotlin已经为数字列表扩展了sum方法，但为了方便演示，我们重新实现一边算法）*

// 过程式代码：
    fun main(args: Array<String>) {
        val ints = listOf(1, 2, 3, 4, 5)
        var sum = 0
        for (i in ints) sum += i
        sum.log() // Log 15
    }
     
      
     
      
       1
       2
       3
       4
       5
       6
       7

注释：  
*fun（function）关键字用于定义一个函数，在Kotlin中，函数可以定义在任意位置，因此main函数也不需要被包裹在类里面。*  
*val（value）关键字定义一个不可变的变量，使用val关键字定义的变量不可以重新赋值。Kotlin具有类型推导的功能，如果变量的类型可以通过=右边的表达式推测出来，就可以省略变量的类型声明。*  
*listOf函数用于构造一个**不可变**列表，不可变的数据结构不提供增删改的操作。*  
*var（variable）关键字用于定义一个可变的变量。*  
*for in循环遍历ints中的每一个元素，依次将元素赋值给i*  
*.log()是一个自定义的扩展方法，用于将表达式的值呈现在控制台：*

fun Any.log() = println(this)
     
      
     
      
       1

我们再来看一段等效的函数式代码：

// 函数式代码：
    fun main(args: Array<String>) {
        val ints = listOf(1, 2, 3, 4, 5)
        ints.fold(0){ a, b -> a + b }.log()
        // Log 15
    }
     
      
     
      
       1
       2
       3
       4
       5
       6

函数式的代码更加简洁一些，并且没有定义sum变量，而是使用fold方法对列表进行求和。fold方法对列表进行折叠，它接受两个参数，第一个参数是初始值，第二个参数是一个函数。这里我们使用了Lambda表达式，Lambda表达式是一个匿名函数，在这里，它等效于：

// 函数体只有一条语句时，包裹函数体的花括号可以简化成等号
    fun plus(a: Int, b: Int): Int = a + b
     
      
     
      
       1
       2

像fold这样接受另一个函数作为参数，或是返回一个函数的函数，我们称之为“**高阶函数**”，在Kotlin中，如果要传入一个Lambda表达式给一个函数的**最后一个参数**，那么该Lambda表达式可以被放置在函数调用的小括号外侧。  
fold方法遍历整个列表，不断将列表中的元素与初始值“结合”，而结合的方法就是我们提供的Lambda，即将两个整数相加：  
![这里写图片描述][SouthEast]  
从图中可以看出，fold采用的算法其实和过程式直接用循环是一样的。  
从这个简单的例子中，我们大概能看出一丝函数式编程的风格，但仍然没有体现出函数式编程的优势。我们再通过一个更加复杂的例子来观察一下：

// 过程式代码：
    fun main(args: Array<String>) {
        val list = listOf(
                listOf(1, 2, 3),
                listOf(4, 5, 6),
                listOf(7, 8, 9)
        )
        // 求出每一个子列表的乘积，再求和
        var sum = 0
        for (sub in list) {
            var product = 1
            for (i in sub) product *= i
            sum += product
        }
        sum.log() // Log 630
    }
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16

似乎代码变得复杂了起来，我们必须读完整个循环才能明白程序的意图。那么函数式如何呢：

// 函数式代码：
    fun main(args: Array<String>) {
        val list = listOf(
                listOf(1, 2, 3),
                listOf(4, 5, 6),
                listOf(7, 8, 9)
        )
        list.map { it.fold(1){ a, b -> a * b } }
                .fold(0){ a, b -> a + b }
                .log() // log 630
    }
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11

这里调用了map方法。map方法将函数应用到列表的每一个元素上，从而转化整个列表。再来观察一下这个Lambda表达式：

{ it.fold(1){ a, b -> a * b } }
     
      
     
      
       1

在Kotlin中，如果一个Lambda表达式只有一个参数，那么可以使用it关键字来指代这个参数，从而省略参数列表。在这里，it指代的是list中的子列表。我们对每一个子列表都采用乘法进行折叠。由于折叠之后，整个列表被折成了一个整数，所以在调用map之后，list从一个嵌套的二维列表变成了一个一维的列表。  
第二个fold则和第一个例子中对整数求和的fold方法一模一样。  
这么写的好处是显而易见的：在过程式的代码中，我们再阅读循环时，必须追踪其中的每一个变量（sum, product, sub 和 i）才能弄明白程序的意图，而函数式的代码则不依赖任何外部变量和上下文，每条语句要表达的计算已经完全包含在这条语句中了。  
你可能会说，过程式代码容易debug，比如，我们想要查看每一个子表达式的乘积，只需要条件一条语句：

...
        for (sub in list) {
            var product = 1
            for (i in sub) product *= i
            product.log()
            sum += product
        }
    ...
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8

事实上，函数式的代码同样可以实现，并且不需要破坏现有的调用链：

...
        list.map { it.fold(1){ a, b -> a * b } }
                .apply { log() }
                .fold(0){ a, b -> a + b }
                .log() // log 630
     
      
     
      
       1
       2
       3
       4
       5

apply方法比较特殊，obj.apply\{ log() \}相当于调用了：

fun <T> f(obj: T): T {
        obj.log()
        return obj
    }
     
      
     
      
       1
       2
       3
       4

它可以在不破坏调用链的情况下调用一个对象上的返回值为Unit的方法。

[SouthEast]: https://img-blog.csdn.net/20171128102923254?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvS2hlbGxlbmRyb3M=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast