前言

上一篇文章，咱们通过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, func: (String) -> Unit) {

list.forEach {

func.invoke(it)

}

}

// 直接把函数以参数的形式，传进去

logList(mutableListOf(“111”,“222”,“333”),::logString)

// 非高阶函数

interface LogString {

fun invoke(string: String)

}

fun logList(list: MutableList, 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): List {

val result=mutableListOf()

for (i in list.indices){

result.add(list[i].toString())

}

return result

}

// Kotlin实现，map操作符

fun List.listLongToString(): List {

return this.map { it.toString() }

}

打平某种类型的集合

// Java实现

fun getAllNames(list: List): List {

val result=mutableListOf()

for (i in list.indices) {

for (j in list[i].nameList.indices) {

result.add(list[i].nameList[j])

}

}

return result

}

// Kotlin，flatMap操作符

fun List.getAllNames(): List {

return this.flatMap { it.nameList }

}

过滤掉所有为null的集合

// Java实现

fun filterNullOrEmpty(list:List):List{

val result=mutableListOf()

for (i in list.indices){

if (!list[i].isNullOrEmpty()){

result.add(list[i]!!)

}

}

return result

}

// Kotlin，filter操作符

fun List.filterNullOrEmpty:List{

return this.filterNotNull().filterNot { it.isEmpty() }

}

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

listOf(“123”, “1”, “2”, “3”, “12”, “321”, “21”, “45”, “1234”, “5678”)By { it.length }.map {

Log.d(“mdove”, “${it.key} - ${it.value}”)

}

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

思想交融，Android中的函数式编程（1）：什么事函数式编程

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的代码对比，基本能够感受到函数式所带来的不一样的编程体验。

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