scala 学习笔记（中） | 函数式编程

Scala 是一门多范式（multi-paradigm）的编程语言，设计初衷是要集成面向对象编程和函数式编程的各种特性。Scala 运行在 Java 虚拟机上，并兼容现有的 Java 程序。





下面是我的scala学习笔记连接：

• Scala学习笔记（上）| 开发环境安装 | 循环判断 | 数据类型
• Scala 学习笔记（中） | 函数式编程
• Scala 学习笔记（下） | 类和对象、特质

---

函数式编程

使用Spark/Flink的大量业务代码都会使用到函数式编程，都有下面这些操作：

• 遍历（foreach）
• 映射（map）
• 映射扁平化（flatmap）
• 过滤（filter）
• 是否存在（exists）
• 排序（sorted、sortBy、sortWith）
• 分组（groupBy）
• 聚合计算（reduce）
• 折叠（fold）

1、遍历 | foreach

之前学习过了使用for表达式来遍历集合，使用foreach方法进行遍历、迭代，可以让代码更加简介

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

foreach执行过程：

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

val a = List(1,2,3,4)
a.foreach((x:Int)=>println(x))

2、使用类型推断简化函数定义

上述案例函数定义有点啰嗦，有更简洁的写法，因为使用foreach去迭代列表，而列表中的每个元素类型式确定的

• scala可以自动来推断出来集合中每个元素参数的类型
• 创建函数时，可以省略其参数列表的类型

示例：

1、有一个列表，包含1，2，3，4，使用foreach方法遍历打印每个元素

2、使用类型推断简化函数定义

val a = List(1,2,3,4)
//省略参数类型
a.foreach(x=>println(x))

3、使用下划线来简化函数定义

当函数参数，只在函数体中出现一次，而且函数体没有嵌套调用时，可以使用下划线来简化函数定义

示例：

1、有一个列表，包含1，2，3，4

2、使用下划线简化函数定义

val a = List(1,2,3,4)
a.foreach(println(_))

• 如果方法参数是函数，如果出现了下划线，scala编译器会自动将代码封装到一个函数中
• 参数列表也是由scala编译器自动处理

4、映射 | map

集合的映射操作是将来编写spark/Flink用的最多的操作，必须要掌握！因为进行数据计算的时候，就是一个将一种数据类型转换为另一种数据类型的过程

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

def map[B](f: (A) => B): TraversableOnce[B]

方法解析：

map方法解析：

案例一：

1、创建一个列表，包含元素1，2，3，4

2、对List中的每一个元素加1

val a = List(1,2,3,4)
a.map(x=>x+1) 或 a.map(_+1)
res1: List[Int] = List(2,3,4,5)

5、扁平化映射 | flatMap

• map是将列表中的元素转换成一个List
• flatten再将整个列表进行扁平化

方法签名：

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

案例：

1、有一个包含了若干个文本行的列表：“hadoop hive spark flink flume”,“kudu hbase sqoop storm”

2、获取到文本行中的每一个单词，并将每一个单词都放到列表中

思路：

步骤：

• 使用map将文本行拆分成数组
• 再对数组进行扁平化

val a = List("hadoop hive spark flink flume","kudu hbase sqoop storm")
a.map(_.split(" "))
输出：
res0: List[Array[String]] = List(Array(hadoop,hive,spark,flink,flume),Array(kudu,hbase,sqoop,storm))

res0.flatten
res1: List[String] = List(hadoop,hive,spark,flink,flume,kudu,hbase,sqoop,storm)

使用flatMap简化操作：

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

6、过滤 | filter

过滤符合一定条件的元素

定义：

def filter(p: (A) => Boolean): TraversableOnce[A]

案例：

1、有一个数字列表，元素为：1，2，3，4，5，6，7，8，9

2、请过滤出所有的偶数

List(1,2,4,5,6,7,8,9).filter(_ % 2 == 0)

7、排序

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

• sorted默认排序
• sortBy指定字段排序
• sortWith自定义排序

1）默认排序 | sorted

示例：

1、定义一个列表，包含以下元素：3，1，2，9，7

2、对列表进行升序排序

List(3,1,2,9,7).sorted

2）指定字段排序 | sortBy

def sortBy[B](f: (A) => B): List[A]

示例：

1、有一个列表，分别包含以下文本行：“01 hadoop”,“02 flume”,“03 hive”,“04 spark”

2、请按照单词字母进行排序

val a = List("01 hadoop","02 flume","03 hive","04 spark")
a.sortBy(_.split(" ")(1))

3）自定义排序 | sortWith

def sortWith(lt: (A,A) => Boolean): List[A]

示例：

1、有一个列表，包含以下元素：2，3，1，6，4，5

2、使用sortWith对列表进行降序排序

val a = List(2,3,1,6,4,5)
a.sortWith((x,y)=>if(x<y) true else false)

res1.reverse

a.sortWith(_ > _)

8、分组 | groupBy

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

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

groupBy执行过程分析

示例：

1、有一个列表，包含了学生的姓名和性别

"张三","男"
"李四","女"
"王五","男"

2、请按照性别进行分组，统计不通性别的学生人数

步骤：

1、定义一个元组列表来保存学生姓名和性别

2、按照性别进行分组

3、将分组后的Map转换为列表：List((“男”->2),(“女”->1))

val a = List("张三"->"男","李四"->"女","王五"->"男")
a.groupBy(x=>x._2).map(x=>x._1 -> x._2.size).toList

9、聚合操作

可以将一个列表中的数据合并为一个

1）聚合 | reduce

reduce表示将列表，传入一个函数进行聚合计算

def reduce[A1 >: A](op: (A1,A1) => A1): A1

reduce执行流程分析：

Note

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

案例：

1、定义一个列表，包含：1，2，3，4，5，6，7，8，9，10

2、使用reduce计算所有元素的和

val a = List(1,2,3,4,5,6,7,8,9,10)
a.reduce((x,y) => x+y)
res1: Int = 55
a.reduce(_ + _)
res2: Int = 55
//从左往右计算
a.reduceLeft(_ + _)

2）折叠 | fold

def fold[A1 >: A](z: A1)(op: (A1,A1) => A1):A1

Note

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

案例：

1、定义一个列表，包含：1，2，3，4，5，6，7，8，9，10

2、使用fold计算所有元素的和

val a = List(1,2,3,4,5,6,7,8,9,10)
a.fold(0)(_+_)