Scala函数式编程

概念

函数

一种具有名或匿名的操作。其代码直到被调用时才执行。在函数的定义中，可能有也可能没有引用外部的未绑定变量。

def 函数名([参数名: 参数类型],...) [: 返回值类型] = {
 	语句
 	[return] 返回值
}

1. 函数声明的关键字是 def
2. [参数名: 参数类型],…：参数列表，如果有必须给出参数类型。多个参数使用逗号分隔。如果没有形参，括号也可以省略
3. [: 返回值类型] ：表示函数的返回值类型，函数可以没有返回值。如果没有返回值，return不生效。只要不是递归函数，就不需要显示指定返回值类型，Scala会自动推断。
4. 每行语句不用分号";“结束，写上也没错。但是单行包含多条语句，需要使用分号”;"分隔。
5. return: 返回结果。 不用显示调用return，默认以最后一行结果作为返回值。如果显示的调用了return，则必须指定返回值类型。推荐不显示调用return。
6. 如果函数明确声明无返回值（声明Unit），那么函数体中即使使用return关键字也不会有返回值

Lambda

一种匿名函数。在它的定义中，可能有也可能没有引用外部的未绑定变量。

闭包

是一个函数，可能匿名或具有名称，在定义中包含了自由变量，函数中包含了环境信息，以绑定其引用的自由变量。

var factor = 2
val mul = (i:Int) => i * factor
(1 to 3).map(mul) // Vector(2,4,6)
factor = 3
(1 to 3).map(mul) // Vector(3,6,9)

factor是一个自由变量，是一个当前作用域中某个值的引用。编译器创建了一个闭包，用于包含mul与它引用的外部变量的上下文信息，从而也就绑定了外部变量本身。所以mul每次调用时都重新读取factor的值。即使factor处于某个局部作用域（如某个方法）中，而我们将mul传递给其他作用域中时，这一机制仍然有效。

函数式编程

• 函数式编程把函数当做一等公民，充分利用函数，支持的函数的多种使用方式。
• “函数式编程"是一种"编程范式”（programming paradigm）。它属于"结构化编程"的一种，主要思想是把运算过程尽量写成一系列嵌套的函数调用。
• 函数式编程中，将函数也当做数据类型，因此可以接受函数当作输入（参数）和输出（返回值）。

常见函数式编程

遍历（foreach）

foreach方法可以进行遍历数组

方法签名

foreach(f: (A) => Unit): Unit 

方法解析

foreach	API	说明
参数	f:(A) => Unit	接收一个函数对象，函数的输入参数为集合的元素，返回值为空
返回值	Unit	空

foreach执行过程

示例
有一个列表，包含以下元素1,2,3,4，请使用foreach方法遍历打印每个元素

参考代码

// 定义一个列表
scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)
// 迭代打印
scala> a.foreach((x:Int)=>println(x))

映射（map）

map方法接收一个函数，将这个函数应用到每一个元素，返回一个新的列表

方法签名

def map[B](f: (A) ⇒ B): TraversableOnce[B]

方法解析

map	API	说明
泛型	[B]	指定map方法最终返回的集合泛型
参数	f:(A) => B	传入一个函数对象，该函数接收一个类型A（要转换的列表元素），返回值为类型B
返回值	TraversableOnce[B]	B类型的集合

map执行过程

示例
有一个列表，包含以下元素1,2,3,4，使用下划线来定义函数，对List中的每一个元素加1

参考代码

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

scala> a.map(_ + 1)

映射扁平化（flatMap）

可以把flatMap，理解为先map，然后再flatten。map是将列表中的元素转换为一个List，flatten再将整个列表进行扁平化。

方法签名

def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): TraversableOnce[B]

方法解析

map	API	说明
泛型	[B]	最终要转换的集合元素类型
参数	f:(A) => GenTraversableOnce[B]	传入一个函数对象，函数的参数是集合的元素，函数的返回值是一个集合
返回值	TraversableOnce[B]	B类型的集合

flatMap执行过程

示例
有一个包含了若干个文本行的列表：“hadoop hive spark flink flume”, “kudu hbase sqoop storm”，获取到文本行中的每一个单词，并将每一个单词都放到列表中

参考代码

scala>  val a = List("hadoop hive spark flink flume", "kudu hbase sqoop storm")
a: List[String] = List(hadoop hive spark flink flume, kudu hbase sqoop storm)

scala> a.flatMap(_.split(" "))
res7: List[String] = List(hadoop, hive, spark, flink, flume, kudu, hbase, sqoop, storm)

过滤（filter）

过滤符合一定条件的元素

方法签名

def filter(f: (A) ⇒ Boolean): TraversableOnce[A]

方法解析

filter	API	说明
参数	f:(A) ⇒ Boolean	传入一个函数对象，接收一个集合类型的参数，返回布尔类型，满足条件返回true, 不满足返回false

filter执行过程

示例
有一个数字列表，元素为：1,2,3,4,5,6,7,8,9；请过滤出所有的偶数

参考代码

scala> List(1,2,3,4,5,6,7,8,9).filter(_ % 2 == 0)
res8: List[Int] = List(2, 4, 6, 8)

是否存在（exists）

排序（sorted、sortBy、sortWith）

在scala集合中，可以使用以下几种方式来进行排序

1. sorted默认排序
2. sortBy指定字段排序
3. sortWith自定义排序

默认排序（sorted）

示例
定义一个列表，包含以下元素: 3, 1, 2, 9, 7；对列表进行升序排序

参考代码

scala> List(3,1,2,9,7).sorted
res16: List[Int] = List(1, 2, 3, 7, 9)

指定字段排序 （sortBy）

根据传入的函数转换后，再进行排序

方法签名

def sortBy[B](f: (A) ⇒ B): List[A]

方法解析

sortBy	API	说明
泛型	[B]	按照什么类型来进行排序
参数	f: (A) => B	传入函数对象，接收一个集合类型的元素参数，返回B类型的元素进行排序
返回值	List[A]	返回排序后的列表

示例
有一个列表，分别包含几下文本行：“01 hadoop”, “02 flume”, “03 hive”, “04 spark”，请按照单词字母进行排序

参考代码

scala> val a = List("01 hadoop", "02 flume", "03 hive", "04 spark")
a: List[String] = List(01 hadoop, 02 flume, 03 hive, 04 spark)

// 获取单词字段
scala> a.sortBy(_.split(" ")(1))
res8: List[String] = List(02 flume, 01 hadoop, 03 hive, 04 spark)

自定义排序 （sortWith）

自定义排序，根据一个函数来进行自定义排序

方法签名

def sortWith(f: (A, A) ⇒ Boolean): List[A]

方法解析

sortWith	API	说明
参数	f: (A, A) ⇒ Boolean	传入一个比较大小的函数对象，接收两个集合类型的元素参数，返回两个元素大小，小于返回true，大于返回false
返回值	List[A]	返回排序后的列表

示例
有一个列表，包含以下元素：2,3,1,6,4,5，使用sortWith对列表进行降序排序

参考代码

scala> val a = List(2,3,1,6,4,5)
a: List[Int] = List(2, 3, 1, 6, 4, 5)

// 函数参数只在函数中出现一次，可以使用下划线代替
scala> a.sortWith(_ < _).reverse
res19: List[Int] = List(6, 5, 4, 3, 2, 1)

分组（groupBy）

我们如果要将数据按照分组来进行统计分析，就需要使用到分组方法

方法签名

def groupBy[K](f: (A) ⇒ K): Map[K, List[A]]

方法解析

groupBy	API	说明
泛型	[K]	分组字段的类型
参数	f: (A) ⇒ K	传入一个函数对象，接收集合元素类型的参数，返回一个K类型的key，这个key会用来进行分组，相同的key放在一组中
返回值	Map[K, List[A]]	返回一个映射，K为分组字段，List为这个分组字段对应的一组数据

groupBy执行过程

示例
定义一个元组列表来保存学生姓名和性别 【“张三”, “男”,“李四”, “女”,“王五”, “男”】，按照性别进行分组，将分组后的Map转换为列表：List((“男” -> 2), (“女” -> 1))

参考代码

scala> val a = List("张三"->"男", "李四"->"女", "王五"->"男")
a: List[(String, String)] = List((张三,男), (李四,女), (王五,男))

// 按照性别分组
scala> a.groupBy(_._2)
res0: scala.collection.immutable.Map[String,List[(String, String)]] = Map(男 -> List((张三,男), (王五,男)),
女 -> List((李四,女)))

// 将分组后的映射转换为性别/人数元组列表
scala> res0.map(x => x._1 -> x._2.size)
res3: scala.collection.immutable.Map[String,Int] = Map(男 -> 2, 女 -> 1)

聚合计算（reduce）

聚合操作，可以将一个列表中的数据合并为一个。这种操作经常用来统计分析中

方法签名

def reduce[A1 >: A](f: (A1, A1) ⇒ A1): A1

方法解析

reduce	API	说明
泛型	[A1 >: A]	（下界）A1必须是集合元素类型的子类
参数	f: (A1, A1) ⇒ A1	传入函数对象，用来不断进行聚合操作，第一个A1类型参数为：当前聚合后的变量，第二个A1类型参数为：当前要进行聚合的元素
返回值	A1	列表最终聚合为一个元素

reduce执行过程

• reduce和reduceLeft效果一致，表示从左到右计算
• reduceRight表示从右到左计算

示例
定义一个列表，包含以下元素：1,2,3,4,5,6,7,8,9,10, 使用reduce计算所有元素的和

参考代码

scala> val a = List(1,2,3,4,5,6,7,8,9,10)
a: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> a.reduce((x,y) => x + y)
res5: Int = 55

// 第一个下划线表示第一个参数，就是历史的聚合数据结果
// 第二个下划线表示第二个参数，就是当前要聚合的数据元素
scala> a.reduce(_ + _)
res53: Int = 55

// 与reduce一样，从左往右计算
scala> a.reduceLeft(_ + _)
res0: Int = 55

// 从右往左聚合计算
scala> a.reduceRight(_ + _)
res1: Int = 55

折叠（fold）

fold与reduce很像，但是多了一个指定初始值参数

方法签名

def fold[A1 >: A](z: A1)(f: (A1, A1) ⇒ A1): A1

方法解析

reduce	API	说明
泛型	[A1 >: A]	（下界）A1必须是集合元素类型的子类
参数1	z: A1	初始值
参数2	f: (A1, A1) ⇒ A1	传入函数对象，用来不断进行聚合操作，第一个A1类型参数为：当前折叠后的变量，第二个A1类型参数为：当前要进行折叠的元素
返回值	A1	列表最终折叠为一个元素

• fold和foldLet效果一致，表示从左往右计算
• foldRight表示从右往左计算

示例
定义一个列表，包含以下元素：1,2,3,4,5,6,7,8,9,10, 使用fold计算所有元素的和

参考代码

scala> val a = List(1,2,3,4,5,6,7,8,9,10)
a: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> a.fold(0)(_ + _)
res4: Int = 55