阅读 567

思想交融,Android中的函数式编程(2):什么是函数式编程

前言

上一篇文章,咱们通过DiffUtil来引出了函数式的那么一点点内容。今天的文章,将会重点聊一聊函数式编程所能给我们开发模式上的改变。

思想交融,Android中的函数式编程(1):DiffUtil体验

一、什么是函数式编程

解答这个问题,让我们直接上维基百科吧:

函数式编程(functional programming),是一种编程范式,它将计算机运算视为函数运算,并且避免使用程序状态(也就是咱们上篇文章提到的stateless)以及不可变对象(上篇文章提到的immutable)。其中,λ演算(lambda表达式)为该语言最重要的基础。而且,λ演算的函数可以接受函数当作输入(引数)和输出(传出值)(也就是Kotlin中所推崇的高阶函数)。

概念巴拉巴拉说了一大堆,总结一下也就是:

  • 代码无状态
  • 使用不可变对象
  • Lambda表达式和高阶函数

接下来,咱们一一展开这些内容:

二、函数式编程的特点

2.1、无状态(stateless)

这个特性讲究的是:函数不维护任何状态

咋理解呢?对于函数式编程来说,函数所做的,就是接受输入,然后处理完返回输出。重点在于,函数执行完毕前,内部的任何变量是永远不会被函数外所改变的。也就是说,参与函数执行的变量永远是局部变量!

在代码里就是这个样子:

// 非函数式,有状态(Stateful)
// 这里有个成员变量,调这个全局函数变量++,这里面是有状态的,这个状态在外部。所以,如果是多线程的话,这里面的代码是不安全的。
class StatefulAddition{
    var result = 0
    fun addOneCount():Int{
        result++
        return result
    }
}

// 函数式,无状态(Stateless)
class StatelessAddition{
    fun addOneCount(one :Int): Int{
        return one + 1
    }
}
复制代码

感受到二者在编码方式上的不同了吧。没感受到?那就好好感受一下子...

这里咱们想一想,函数式编程讲究这样的思想,有什么好处呢?

我们知道,因为状态的存在,在并行执行时引发bug的概率是非常高的,毕竟多线程操作成员变量的行为很常见(我们可以使用加锁的方式去解决问题),稍不留神就会被坑。所以没有状态就没有伤害(毕竟在这种思想下,代码的执行不包括中间状态的出现)。

2.2、不可变变量(immutable)

immutable这个概念需要好好感受。这个概念正好印证了Kotlin中val关键字的设计。我们千万不要单纯的把val和Java中final关键字“混为一谈”。(虽然好像它们就是一个东西)

val定义一个不可变的变量,也就是说这个变量一但被声明将不能被再次赋值。这也就是immutable所推崇的意义(Kotlin中val就是immutable的具体实现)。

让我们上一段代码,感受一下:

// Mutable
// 类中的成员变量都是以var声明的
data class MutableModel(var name: String)
data class ImmutableModel(val name: String)

val mutableModel = MutableModel("mdove")
val newNameMutaleModel = mutableModel.apply { name = "new mdove" }

// Immutable
// 类中的成员变量都是以val声明的,意味着:想换个name,必须得重新new这个类
val immutableModel = ImmutableModel("mdove")
val newNameMutableModel1 = ImmutableModel("new mdove")
// data class 特有的复制变量的方式(就是一种快捷的new)
val newNameMutableModel2 = immutableModel.copy("new mdove")
复制代码

OK,这就是immutable。还记不记得,我们在上篇文章中提到过:

因为DiffUtil设计本身就是对不同的集合对象进行diff。因此我们在update的时候,就必须要输入俩个不同的集合实例。

所以Immutable这个特性,完美的对应了Diff的特性。所以Immutable的特性在很多框架或者业务场景中非常非常的合适以及好用。这里先有一个关于此的印象,然后在随后的业务中慢慢去感受,慢慢感受~

2.3、高阶函数

在函数式编程中引入了高阶函数的概念,概念可能在Java中并不是很常见。咱们用一段代码来感受一下高阶函数在Kotlin中的应用,以及它在Java中的能找到的类似实现。

// 高阶函数
fun logString(mValue: String) {
    Log.d("mdove", mValue)
}

fun logList(list: MutableList<String>, func: (String) -> Unit) {
    list.forEach {
        func.invoke(it)
    }
}
// 直接把函数以参数的形式,传进去
logList(mutableListOf("111","222","333"),::logString)


// 非高阶函数
interface LogString {
    fun invoke(string: String)
}

fun logList(list: MutableList<String>, logString: LogString) {
    list.forEach {
        logString.invoke(it)
    }
}
// 匿名内部类的方式执行
logList(mutableListOf("111", "222", "333"), object :LogString{
    override fun invoke(string: String) {
        Log.d("mdove", string)
    }
})
复制代码

高阶函数的出现,让函数式编程变得异常的方便,极大的提高了我们的开发效率。现在已经入手Kotlin的小伙伴,肯定对Kotlin中“变化多端”的操作符搞的大呼“真香”了吧?

2.4、操作符

因为高阶函数的存在,Kotlin中存在很多效率爆炸的操作符,接下来让我们通过具体的操作符和Java中的实现进行对比。直接上代码,从代码中感受一切~~~

遍历一种类型的集合,然后转换成另种类型的集合

// Java实现
fun listLongToString(list: List<Long>): List<String> {
    val result= mutableListOf<String>()
    for (i in list.indices){
        result.add(list[i].toString())
    }
    return result
}
// Kotlin实现,map操作符
fun List<Long>.listLongToString(): List<String> {
    return this.map { it.toString() }
} 
复制代码

打平某种类型的集合

// Java实现
fun getAllNames(list: List<TestModel>): List<String> {
    val result = mutableListOf<String>()
    for (i in list.indices) {
        for (j in list[i].nameList.indices) {
            result.add(list[i].nameList[j])
        }
    }
    return result
}
// Kotlin,flatMap操作符
fun List<TestModel>.getAllNames(): List<String> {
    return this.flatMap { it.nameList }
}
复制代码

过滤掉所有为null的集合

// Java实现
fun filterNullOrEmpty(list:List<String?>):List<String>{
    val result = mutableListOf<String>()
    for (i in list.indices){
        if (!list[i].isNullOrEmpty()){
            result.add(list[i]!!)
        }
    }
    return result
}
// Kotlin,filter操作符
fun List<String?>.filterNullOrEmpty:List<String>{
    return this.filterNotNull().filterNot { it.isEmpty() }
}
复制代码

最后整一个有趣的操作符:groupBy

listOf("123", "1", "2", "3", "12", "321", "21", "45", "1234", "5678").groupBy { it.length }.map {
    Log.d("mdove", "${it.key} - ${it.value}")
}
复制代码

直接通过输出结果,来感受这个操作符的魅力吧:

2.5、表达式

最后想聊一聊表达式(Expression)这个特性,表达式随处可见。val num = a + b;这里的a + b就是一个表达式,它赋值给某个变量。这似乎很正常,但是有“不正常”的:

让我们来感受一下Kotlin中更为强大的表达式用法:

// 比较俩个数的大小,并输出大的。在Java中的实现可以是这样:
fun sMax(a:Int,b:Int):Int{
    var result=0
    if(a>b){
        result=a
    }else{
        result=b
    }
    return result
}
// 可以在Kotlin中if-else是一个表达式,也就是说它可以赋值给变量,因此在Kotlin中的实现是这样的:
fun eMax(a:Int,b:Int):Int{
    return if(a>b) a else b
}
复制代码

尾声

关于函数式的概念,我想文章已经写的足够清楚了。并且其中关于Java和Kotlin的代码对比,基本能够感受到函数式所带来的不一样的编程体验。

这里并非是推崇和安利函数式编程,更多的是一种融合。有些时候我们的确需要看看“外面的世界”,感受更大更有趣的编程世界~~

我是一个应届生,最近和朋友们维护了一个公众号,内容是我们在从应届生过渡到开发这一路所踩过的坑,以及我们一步步学习的记录,如果感兴趣的朋友可以关注一下,一同加油~

个人公众号:咸鱼正翻身

关注下面的标签,发现更多相似文章
评论