函数式编程
我们将来使用Spark/Flink的大量业务代码都会使用到函数式编程。
下面的这些操作是学习的重点,先来感受下如何进行函数式编程以及它的强大
遍历 - foreach
方法描述
1 | foreach(f: (A) ⇒ Unit): Unit |
方法说明
foreach | API | 说明 |
---|---|---|
参数 | f: (A) ⇒ Unit | 接收一个函数对象作为参数 函数的输入参数为集合的元素 返回值为空 |
返回值 | Unit | 空 |
方法实操
1 | scala> val list = List(1, 2, 3, 4) |
映射 - map
集合的映射操作是将来在编写Spark/Flink用得最多的操作,是我们必须要掌握。
方法描述
1 | def map[B](f: (A) ⇒ B): TraversableOnce[B] |
方法说明
map方法 | API | 说明 |
---|---|---|
泛型 | [B] | 指定map方法最终返回的集合泛型 |
参数 | f: (A) ⇒ B | 传入一个函数对象作为参数 该函数接收一个类型A(要转换的集合的元素类型) 返回值为类型B |
返回值 | TraversableOnce[B] | B类型的集合 |
方法实操
1 | //定义一个list集合,实现把内部每一个元素做乘以10,生成一个新的list集合 |
扁平化映射 - flatmap
映射扁平化也是将来用得非常多的操作,也是必须要掌握的。
方法描述
1 | def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): TraversableOnce[B] |
方法说明
flatmap方法 | API | 说明 |
---|---|---|
泛型 | [B] | 最终要转换的集合元素类型 |
参数 | f: (A) ⇒ GenTraversableOnce[B] | 传入一个函数对象作为参数 函数的参数是集合的元素 函数的返回值是一个集合 |
返回值 | TraversableOnce[B] | B类型的集合 |
方法实操
1 | //定义一个List集合,每一个元素中就是一行数据,有很多个单词 |
过滤 - filter
过滤符合一定条件的元素
方法描述
1 | def filter(p: (A) ⇒ Boolean): TraversableOnce[A] |
方法说明
filter方法 | API | 说明 |
---|---|---|
参数 | p: (A) ⇒ Boolean | 传入一个函数对象作为参数 函数的参数是集合中的元素 此函数返回布尔类型,满足条件返回true, 不满足返回false |
返回值 | TraversableOnce[A] | 列表 |
方法实操
1 | //定义一个list集合 |
排序 - sort
在scala集合中,可以使用以下几种方式来进行排序
- sorted默认排序
- sortBy指定字段排序
- sortWith自定义排序
sorted默认排序
1 | //定义一个List集合 |
sortBy指定字段排序
根据传入的函数转换后,再进行排序
方法描述
1 | def sortBy[B](f: (A) ⇒ B): List[A] |
方法说明
sortBy方法 | API | 说明 |
---|---|---|
泛型 | [B] | 按照什么类型来进行排序 |
参数 | f: (A) ⇒ B | 传入函数对象作为参数 函数接收一个集合类型的元素为参数 返回B类型的元素进行排序 |
返回值 | List[A] | 返回排序后的列表 |
方法实操
1 | //定义一个List集合 |
sortWith自定义排序
自定义排序,根据一个函数来进行自定义排序
方法描述
1 | def sortWith(lt: (A, A) ⇒ Boolean): List[A] |
方法说明
sortWith方法 | API | 说明 |
---|---|---|
参数 | lt: (A, A) ⇒ Boolean | 传入一个比较大小的函数对象作为参数 函数接收两个集合类型的元素作为参数 返回两个元素大小,小于返回true,大于返回false |
返回值 | List[A] | 返回排序后的列表 |
方法实操
1 | scala> val list = List(2, 3, 1, 6, 4, 5) |
分组 - groupBy
我们如果要将数据按照分组来进行统计分析,就需要使用到分组方法
groupBy表示按照函数将列表分成不同的组
方法描述
1 | 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为这个分组字段对应的一组数据 |
方法实操
1 | scala> val a = List("张三" -> "男", "李四" -> "女", "王五" -> "男") |
聚合 - reduce
reduce表示将列表,传入一个函数进行聚合计算
方法描述
1 | def reduce[A1 >: A](op: (A1, A1) ⇒ A1): A1 |
方法说明
reduce方法 | API | 说明 |
---|---|---|
泛型 | [A1 >: A] | (下界)A1必须是集合元素类型的子类 |
参数 | op: (A1, A1) ⇒ A1 | 传入函数对象,用来不断进行聚合操作 第一个A1类型参数为:当前聚合后的变量 第二个A1类型参数为:当前要进行聚合的元素 |
返回值 | A1 | 列表最终聚合为一个元素 |
方法实操
1 | scala> val a = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) |
折叠 - fold
fold与reduce很像,但是多了一个指定初始值参数
方法描述
1 | def fold[A1 >: A](z: A1)(op: (A1, A1) ⇒ A1): A1 |
方法说明
reduce方法 | API | 说明 |
---|---|---|
泛型 | [A1 >: A] | (下界)A1必须是集合元素类型的子类 |
参数1 | z: A1 | 初始值 |
参数2 | op: (A1, A1) ⇒ A1 | 传入函数对象,用来不断进行折叠操作 第一个A1类型参数为:当前折叠后的变量 第二个A1类型参数为:当前要进行折叠的元素 |
返回值 | A1 | 列表最终折叠为一个元素 |
方法实操
1 | //定义一个List集合 |
高阶函数
使用函数值作为参数,或者返回值为函数值的“函数”和“方法”,均称之为“高阶函数”。
函数值作为参数
1 | //定义一个数组 |
匿名函数
//定义一个数组
scala> val array = Array(1, 2, 3, 4, 5)
array: Array[Int] = Array(1, 2, 3, 4, 5)
//定义一个没有名称的函数----匿名函数
scala> array.map(x => x * 10)
res1: Array[Int] = Array(10, 20, 30, 40, 50)