《Kotlin 程序设计》第六章 Kotlin 函数式编程(FP)
来源:互联网 发布:arm linux gcc 3.4.1 编辑:程序博客网 时间:2024/06/05 08:57
第六章 Kotlin 函数式编程(FP)
1. 函数式编程概述
从本质上来说, 程序就是一系列有序执行的指令集合。 如何将指令集合组织成可靠可用可信赖的软件(美妙的逻辑之塔), 这是个问题。
首先,什么是函数式编程,这并没有唯一定义,它只是广泛聚合了一些编程风格的特性,我们可以将它与面向对象编程OOP进行对比, 两者区别是,OOP主要聚焦于数据的区别,而FP则注重数据结构的一致性。
函数编程(简称FP)不只代指Haskell Scala等之类的语言,还表示一种编程思维,软件思考方式,也称面向函数编程。
编程的本质是组合,组合的本质是范畴Category,而范畴是函数的组合。
面向对象编程OOP特征:
- 数据和对数据的操作紧紧耦合
- 对象隐藏它们操作的实现细节,其他对象调用这些操作只需要通过接口。
- 核心抽象模型是数据自己
- 核心活动是组合新对象和拓展已经存在的对象,通过加入新的方法实现。
函数式编程FP特征:
- 数据与函数是松耦合的
- 函数隐藏了它们的实现,语言的抽象是函数,以及将函数组合起来表达。
- 核心抽象模型是函数,不是数据结构
- 核心活动是编写新的函数。
- 变量缺省是不变的,减少可变性变量的使用,并发性好[1]
如果说OOP还有很多人可能受静态数据思路影响,那么FP 带来完全是动态事件,FP让我们直接用动词思考,用函数解决问题。
面向对象和面向函数一直在争论,实际上纯粹的OOP和纯粹的FP都是极端的,对于OOP来讲:存在的并一定都是对象,函数就不是对象;对于FP来说:存在的并不总是纯粹的,副作用总是真实存在。
总之,面向对象侧重于自顶向下架构层层分解,函数编程侧重于自底向上层层组合。
2. Kotlin函数式编程
Kotlin对函数式编程的实现恰到好处。
2.1 函数是什么?
在数学中,我们这样定义一个函数:
给定一个集合A,对A施加对应法则f, 记作f(A), 得到另一集合B, 也就是
B=f(A)
. 我们记作:
f: A -> B
这个关系式就叫函数关系式, 简称函数.
函数的类型是: A->B
。 意思是,if A then , we have B = f(A)
. 函数代表一种关系 f
的蕴涵逻辑流。这种蕴涵逻辑流,其实就是映射(Mapping)。
一切皆是映射。
我们说组合是编程的本质,其实,组合就是建立映射关系。
我们说,
程序 = 算法+数据结构
我们把程序看做图论里面的一张图G,这里的数据结构就是图G的节点Node, 而算法逻辑就是这些节点Node之间的Edge。整个的图G就是一幅美妙的抽象逻辑之塔的 映射图 。
2.2 函数指针
我们使用::
引用一个函数。
/** * "Callable References" or "Feature Literals", i.e. an ability to pass * named functions or properties as values. Users often ask * "I have a foo() function, how do I pass it as an argument?". * The answer is: "you prefix it with a `::`". */fun main(args: Array<String>) { val numbers = listOf(1, 2, 3) println(numbers.filter(::isOdd))}fun isOdd(x: Int) = x % 2 != 0
运行结果: [1, 3]
2.3 复合函数(高阶函数(Higher-order function))
函数式编程风格让我们复合函数的写法跟数学表达式一样简洁。看了下面的复合函数的例子,你会发现Kotlin的FP的实现相当简洁,跟纯数学的表达式,相当接近了:
/** * The composition function return a composition of two functions passed to it: * compose(f, g) = f(g(*)). * Now, you can apply it to callable references. */fun main(args: Array<String>) { val oddLength = compose(::isOdd, ::length) val strings = listOf("a", "ab", "abc") println(strings.filter(oddLength))}fun isOdd(x: Int) = x % 2 != 0fun length(s: String) = s.lengthfun <A, B, C> compose(f: (B) -> C, g: (A) -> B): (A) -> C { return { x -> f(g(x)) }}
运行结果: [a,abc]
简单说明下
val oddLength = compose(::isOdd, ::length) val strings = listOf("a", "ab", "abc") println(strings.filter(oddLength))
这就是数学中,复合函数的定义:
h = h(f(g))
g: A->B
f: B->C
h: A->C
g(A)=B
h(A) = f(B) = f(g(A)) = C
只是代码中的写法是:
h=compose( f, g )
h=compose( f(g(A)), g(A) )
/** * The composition function return a composition of two functions passed to it: * compose(f, g) = f(g(*)). * Now, you can apply it to callable references. */fun main(args: Array<String>) { val oddLength = compose(::isOdd, ::length) val strings = listOf("a", "ab", "abc") println(strings.filter(oddLength)) println(strings.filter(::hasA)) println(strings.filter(::hasB)) val hasBStrings = strings.filter(::hasB) println(hasBStrings) val evenLength = compose(::isEven,::length) println(hasBStrings.filter(evenLength))}fun isOdd(x: Int) = x % 2 != 0fun isEven(x:Int) = x % 2 == 0fun length(s: String) = s.lengthfun hasA(x: String) = x.contains("a")fun hasB(x: String) = x.contains("b")fun <A, B, C> compose(f: (B) -> C, g: (A) -> B): (A) -> C { return { x -> f(g(x)) }}fun <W,X,Y,Z> compose2( h: (Y) -> Z, f:(X) -> Y,g:(W) -> X): (W) -> Z { return {x -> h(f(g(x)))} }
你看这个复合函数
fun <W,X,Y,Z> compose2( h: (Y) -> Z, f:(X) -> Y,g:(W) -> X): (W) -> Z { return {x -> h(f(g(x)))} }
看起来很像数学定义,语言可谓优雅漂亮,看着很舒服。
运行结果:
[a, abc][a, ab, abc][ab, abc][ab, abc][ab]
2.4 闭包(Lambda表达式,匿名函数)
我们知道,函数名其实就是一个指向函数的引用变量。如果没有这样一个显式的变量名,编译器当然也会给这段代码按照一个默认规则,创造一个默认的引用。本质其实就是指令中断现场的地址的存储,执行完一段代码(函数逻辑)之后再返回执行之前的地址,继续执行下面的代码。
函数与闭包(匿名函数、无名函数)是 Kotlin 语言提供的重要特性之一。Kotlin的闭包跟Groovy的闭包使用起来类似,直截了当。
在 Kotlin 中与其说一等公民是函数,不如说一等公民是闭包。
例如在 Kotlin 中,你可以写出这种怪异的代码
fun main(args: Array<String>) { test}val test = if (5 > 3) { print("yes")} else { print("no")}
这段代码会输出yes。
这里的if 语句,就是一个闭包。
我们说的Lambda 表达式,就是匿名函数,就是闭包。而匿名函数(闭包),就是匿名的功能代码块了。
Lambda表达式基于数学中的λ演算得名,Lambda表达式可以表示闭包(注意和数学传统意义上的不同)。
Lambda表达式基本语法如下:
- Lambda表达一般使用
{ }
包围。 - 参数(如果有的话)在
->
前定义,参数类型可能是省略的。 - 函数体跟在
->
后面。
我们先来看一个 Lambda 表达式的例子:
// LambdaExpression.ktpackage com.easy.kotlin/** * Created by jack on 2017/5/30. */// Lambda 表达式val fsum0 = { x: Int, y: Int -> x + y }val fsum1 = { x: Int, y: Int -> { x + y } }val fsum2 = fun(x: Int, y: Int): Int = x + yval fsum3 = fun Int.(other: Int): Int = this + otherfun main(args: Array<String>) { println(fsum0(1, 1)) println(fsum0.invoke(1,1)) println(fsum1(1, 1).invoke()) println(fsum2(1, 1)) println(1.fsum3(1))}
可以看到我们定义了一个变量 fsum0
,赋值为一个 Lambda 表达式:
{ x: Int, y: Int -> x + y }
Lambda 表达式用一对大括号括起来,后面先依次写下参数及其类型,如果没有就不写,接着写下->
,这表明后面的是函数体了,函数体的最后一句的表达式结果就是 Lambda 表达式的返回值,比如这里的返回值就是参数求和的结果。
后面我们用 () 的形式: fsum0(1, 1)
调用这个 Lambda 表达式,其实这个 () 对应的是 invoke 方法,换句话说,我们在这里也可以这么写:
fsum0.invoke(1,1)
这两种调用的写法是完全等价的。
我们看到 val fsum1 = { x: Int, y: Int -> { x + y } }
这一句, 跟fsum0相比,函数体多了个{}
。 意思就大不同了。这表明fsum1本身就是一个函数。其调用方式为:
fsum1(1, 1).invoke()
再看 val fsum3 = fun Int.(other: Int): Int = this + other
, 匿名函数语法允许我们直接指定函数字面值的接收者类型(这里是Int
)。然后,我们直接这样调用函数:1.fsum3(1)
。
我们用kotlinc编译LambdaExpression.kt之后,发现目录下生成了这么多的类
./LambdaExpression.kt./LambdaExpressionKt$fsum0$1.class./LambdaExpressionKt$fsum1$1$1.class./LambdaExpressionKt$fsum1$1.class./LambdaExpressionKt$fsum2$1.class./LambdaExpressionKt$fsum3$1.class./LambdaExpressionKt.class
这个我们很熟悉,就是Java中我们看到的内部类。默认命名规则依然是熟悉的配方:$1
, $2
...
我们看这一行
val fsum1 = { x: Int, y: Int -> { x + y } }
对应编译成了两个类文件:
./LambdaExpressionKt$fsum1$1$1.class ./LambdaExpressionKt$fsum1$1.class
其中,./LambdaExpressionKt$fsum1$1$1.class
对应 val fsum1 = { x: Int, y: Int -> { x + y } }
中的{ x + y }
。
而./LambdaExpressionKt$fsum1$1.class
对应的是 val fsum1 = { ... }
外面的 { }
。
自执行闭包就是在定义闭包的同时直接执行闭包,一般用于初始化上下文环境。 例如:
{ x: Int, y: Int -> println("${x + y}")}(1, 3)
闭包(Lambda表达式,匿名函数),在Thread线程执行逻辑里面就显得非常简洁了:
fun testThread() { val startHookThread = Thread({ println("Hello, I am startHookThread") }) startHookThread.start() }
我们会觉得,代码就应该这么写。而不像之前在Java中,要写上一堆样板代码。在Java 8中,也支持了Lambda表达式,写法简洁了许多了。
不过,虽然我们写代码的时候,没有给这段代码块名字, 但是真正到了指令级代码的时候, 还是需要名字的。所以,编译器在处理的时候,会自动给这段匿名函数生成一个名字的
这段代码,kotlinc编译成了:
// access flags 0x1A // signature (Lkotlin/jvm/internal/Ref$ObjectRef<Ljava/lang/String;>;Ljava/lang/String;)V // declaration: void kotlin$lambda-0(kotlin.jvm.internal.Ref$ObjectRef<java.lang.String>, java.lang.String) private final static kotlin$lambda-0(Lkotlin/jvm/internal/Ref$ObjectRef;Ljava/lang/String;)V ALOAD 1 INVOKESTATIC kotlin/io/ConsoleKt.println (Ljava/lang/Object;)V ALOAD 0 NEW java/lang/StringBuilder DUP ALOAD 0 GETFIELD kotlin/jvm/internal/Ref$ObjectRef.element : Ljava/lang/Object; CHECKCAST java/lang/String INVOKESPECIAL java/lang/StringBuilder.<init> (Ljava/lang/String;)V ALOAD 1 INVOKEVIRTUAL java/lang/StringBuilder.append (Ljava/lang/String;)Ljava/lang/StringBuilder; INVOKEVIRTUAL java/lang/StringBuilder.toString ()Ljava/lang/String; PUTFIELD kotlin/jvm/internal/Ref$ObjectRef.element : Ljava/lang/Object; RETURN L0 L1 MAXSTACK = 4 MAXLOCALS = 2 // access flags 0x11 public final testThread()V NEW java/lang/Thread DUP INVOKESTATIC jason/chen/mini_springboot/restful/service/KotlincService.testThread$lambda-0 ()V ACONST_NULL L0 INVOKESPECIAL java/lang/Thread.<init> (Lkotlin/jvm/functions/Function0;)V ASTORE 1 L1 ALOAD 1 INVOKEVIRTUAL java/lang/Thread.start ()V RETURN L2 LOCALVARIABLE startHookThread Ljava/lang/Thread; L1 L2 1 MAXSTACK = 3 MAXLOCALS = 2 // access flags 0x1A private final static testThread$lambda-0()V LDC "Hello, I am startHookThread" INVOKESTATIC kotlin/io/ConsoleKt.println (Ljava/lang/Object;)V RETURN L0 L1 MAXSTACK = 1 MAXLOCALS = 0
我们可以看出,在testThread()函数里面,有这么一段代码:
NEW java/lang/Thread DUP INVOKESTATIC jason/chen/mini_springboot/restful/service/KotlincService.testThread$lambda-0 ()V ACONST_NULL L0 INVOKESPECIAL java/lang/Thread.<init> (Lkotlin/jvm/functions/Function0;)V
其中,$lambda-0()
函数签名如下:
private final static kotlin$lambda-0(Lkotlin/jvm/internal/Ref$ObjectRef;Ljava/lang/String;)
这就是闭包(匿名函数,Lambda表达式)背后真正的执行过程。更多的事情,由编译器去完成了。
Kotlin编译器在编译前端(即词法分析、语法分析、语义分析、中间代码生成)和Java是基本一致的。与Java不同的地方在编译后面的目标代码生成环节。Kotlin编译器在目标代码生成环节做了很多类似于Java封装的事情,比如自动生成Getter/Setter代码、Companion Object转变成静态类、修改类属性为final不可继承等等工作。大部分Kotlin的特性都在这个环节处理产生。可以这么说,Kotlin将我们本来在代码层做的一些封装工作转移到了编译后端阶段,以使得我们可以更加简洁的使用Kotlin语言。
感谢Kotlin编译器,让我们能够很享受地用kotlin写代码。
2.5 filter函数
val ints = intArrayOf(-1, -2, 3, 4, 5, 6) var sum = 0 ints.filter { it > 0 }.forEach { sum = it.fsum3(sum) //sum += it; } println(sum)//18
这里的forEach函数
/** * Performs the given [action] on each element. */@kotlin.internal.HidesMemberspublic inline fun <T> Iterable<T>.forEach(action: (T) -> Unit): Unit { for (element in this) action(element)}
是kotlin.collections._Collections.kt里面的一个扩展方法。
2.6 map函数
val doubled = ints.map { value -> value * 2 } println(doubled)
参考资料
1.http://www.jdon.com/functional.html
- 《Kotlin 程序设计》第六章 Kotlin 函数式编程(FP)
- 《Kotlin极简教程》第六章 Kotlin函数式编程(FP)
- 《Kotlin 程序设计》第五章 Kotlin 面向对象编程(OOP)
- Kotlin函数式编程(一) Kotlin与函数式编程
- 《Kotlin 程序设计》第十二章 Kotlin的多线程:协程(Coroutines)
- 《Kotlin 程序设计》第三章 Kotlin 类型系统
- 《Kotlin 程序设计》第四章 Kotlin 语法基础
- 《Kotlin 程序设计》第十章 Kotlin Native介绍
- 《Kotlin 程序设计》第十一章 Kotlin实现DSL
- Kotlin函数式编程(二) 高阶函数
- Kotlin 第十四章:函数
- 《Kotlin 程序设计》第一章 Kotlin简介
- 《Kotlin 程序设计》第七章 Kotlin 编译过程分析
- 《Kotlin 程序设计》第八章 Kotlin 集成Spring Boot开发
- 《Kotlin 程序设计》第九章 Kotlin与Java混合调用
- 《Kotlin 程序设计》第十三章 使用Kotlin开发JavaScript代码
- 《Kotlin 程序设计》第十四章 使用Kotlin开发Android程序
- 解析Kotlin 函数用法与函数式编程
- STM32F103学习1:由开发软件MDK4.12生成HEX文件与程序下载(串口)
- 《Kotlin 程序设计》第四章 Kotlin 语法基础
- 《Kotlin 程序设计》第五章 Kotlin 面向对象编程(OOP)
- Java中的ReentrantLock和synchronized两种锁定机制的对比
- 希尔排序 java
- 《Kotlin 程序设计》第六章 Kotlin 函数式编程(FP)
- 《Kotlin 程序设计》第七章 Kotlin 编译过程分析
- 《Kotlin 程序设计》第八章 Kotlin 集成Spring Boot开发
- json转化字符串出错时,判断是否严谨
- 《Kotlin 程序设计》第九章 Kotlin与Java混合调用
- spoj 8222 Substrings 可重复的一个串出现了多少次
- 网络获取图片实现无限轮播图
- 《Kotlin 程序设计》第十章 Kotlin Native介绍
- 《Kotlin 程序设计》第十一章 Kotlin实现DSL