函数式编程
我们将来使用Spark/Flink的大量业务代码都会使用到函数式编程。下面的这些操作是学习的重点。
遍历（ foreach ）
映射（ map ）
映射扁平化（ flatmap ）
过滤（ filter ）
是否存在（ exists ）
排序（ sorted 、 sortBy 、 sortWith ）
分组（ groupBy ）
聚合计算（ reduce ）
折叠（ fold ）
遍历 | foreach
之前，学习过了使用for表达式来遍历集合。我们接下来将学习scala的函数式编程，使
用 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))
使用类型推断简化函数定义
上述案例函数定义有点啰嗦，我们有更简洁的写法。因为使用foreach去迭代列表，而列表中的每
个元素类型是确定的
scala可以自动来推断出来集合中每个元素参数的类型
创建函数时，可以省略其参数列表的类型
示例：
有一个列表，包含以下元素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=>println(x))
使用下划线来简化函数定义
当函数参数，只在函数体中出现一次，而且函数体没有嵌套调用时，可以使用下划线来简化函数定
义
示例：
有一个列表，包含以下元素1,2,3,4，请使用foreach方法遍历打印每个元素
使用下划线简化函数定义
scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)
a.foreach(println(_))
如果方法参数是函数，如果出现了下划线，scala编译器会自动将代码封装到一个函数中
参数列表也是由scala编译器自动处理
映射 | map
集合的映射操作是将来在编写Spark/Flink用得最多的操作，是我们必须要掌握。
语法
def map[B](f: (A) ⇒ B): TraversableOnce[B]
解析
| map方法 | API | 说明 |
|---|---|---|
| 泛型 | [B] | 指定map方法最终返回的集合泛型 |
| 参数 | f: (A) ⇒ B | 传入一个函数对象，该函数接收一个类型A（要转换的列表元素），返回值为类型B |
| 返回值 | TraversableOnce[B] | B类型集合 |
示例：
创建一个列表，包含元素1,2,3,4
对List中的每一个元素加1
scala> a.map(x=>x+1)
res4: List[Int] = List(2, 3, 4, 5)
示例：
创建一个列表，包含元素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
映射扁平化也是将来用得非常多的操作，也是必须要掌握的。
- map是将列表中的元素转换为一个List
- flatten再将整个列表进行扁平化
语法
def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): TraversableOnce[B]
方法解析
| flatmap方法 | API | 说明 |
|---|---|---|
| 泛型 | [B] | 最终要转换的集合元素类型 |
| 参数 | f: (A) ⇒ GenTraversableOnce[B] | 传入一个函数对象，函数的参数是集合的元素，函数的返回值是一个集合 |
| 返回值 | TraversableOnce[B] | B类型的集合 |
示例
- 有一个包含了若干个文本行的列表："hadoop hive spark flink flume", "kudu hbase sqoop
storm"
- 获取到文本行中的每一个单词，并将每一个单词都放到列表中
步骤
使用map将文本行拆分成数组
再对数组进行扁平化
如果不使用flatmap来处理代码
// 定义文本行列表
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)
// 使用map将文本行转换为单词数组
scala> a.map(x=>x.split(" "))
res5: List[Array[String]] = List(Array(hadoop, hive, spark, flink, flume), Array(kudu, hbase, sqoop, storm))
// 扁平化，将数组中的元素扁平
scala> a.map(x=>x.split(" ")).flatten
res6: List[String] = List(hadoop, hive, spark, flink, flume, kudu, hbase, sqoop, storm)
使用flatmap简化操作
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)
过滤 | fliter
过滤符合一定条件的元素
语法
def filter(p: (A) ⇒ Boolean): TraversableOnce[A]
方法解析
| fliter方法 | API | 说明 |
|---|---|---|
| 参数 | p: (A) ⇒ Boolean | 传入一个函数对象，接收一个集合类型的参数 ，返回布尔类型，满足条件返回true, 不满足返回false |
| 返回值 | TraversableOnce[A] | 列表 |
示例
有一个数字列表，元素为：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)
默认排序 | sorted
示例
定义一个列表，包含以下元素: 3, 1, 2, 9, 7
对列表进行升序排序
scala> List(3,1,2,9,7).sorted
res16: List[Int] = List(1, 2, 3, 7, 9)
指定字段排序 | sortBy
根据传入的函数转换后，再进行排序
示例
有一个列表，分别包含几下文本行："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
示例
有一个列表，包含以下元素：2,3,1,6,4,5
使用sortBy对列表进行降序排序
如果不使用sortwith步骤
scala> val a = List(2,3,1,6,4,5)
a: List[Int] = List(2, 3, 1, 6, 4, 5)
scala> a.sortWith((x,y) => if(x<y)true else false)
res15: List[Int] = List(1, 2, 3, 4, 5, 6)
scala> res15.reverse
res18: List[Int] = List(6, 5, 4, 3, 2, 1)
使用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]]
示例
- 有一个列表，包含了学生的姓名和性别:
"张三", "男"
"李四", "女"
"王五", "男"
- 请按照性别进行分组，统计不同性别的学生人数
步骤
定义一个元组列表来保存学生姓名和性别
按照性别进行分组
将分组后的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
reduce表示将列表，传入一个函数进行聚合计算
语法：
def reduce[A1 >: A](op: (A1, A1) ⇒ A1): A1
示例
定义一个列表，包含以下元素：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)(op: (A1, A1) ⇒ A1): A1
示例
定义一个列表，包含以下元素：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 = 155
fold和foldLet效果一致，表示从左往右计算
foldRight表示从右往左计算
z的值为初始值，比如写10，就是从10开始累加，如果是上述的0，则从0开始累加
