Scala 中的函数式编程

1.遍历 (foreach)

方法

foreach(f: (A) ⇒ Unit): Unit

方法说明

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

代码示例

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

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

使用foreach去迭代列表，而列表中的每个元素类型是确定的

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

代码示例

//定义一个列表
 val a = List(1,2,3,4)
 // 省略参数类型
 a.foreach(x=>println(x))

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

• 当函数参数，只在函数体中出现一次，而且函数体没有嵌套调用时，可以使用下划线来简化函数定义
• 如果方法参数是函数，如果出现了下划线，scala编译器会自动将代码封装到一个函数中

• 参数列表也是由scala编译器自动处理

代码示例

//定义一个列表
val a = List(1,2,3,4)
//使用下划线简化函数定义
a.foreach(println(_))

2.映射 (map)

进行数据计算的时候，就是一个将一种数据类型转换为另外一种数据类型的过程,因此集合的映射使用的较多的操作
map方法接收一个函数，将这个函数应用到每一个元素，返回一个新的列表

方法

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

方法说明

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

代码示例

//1. 创建一个列表，包含元素1,2,3,4
val a = List(1,2,3,4)
//2. 对List中的每一个元素加1
a.map(x=>x+1)
//3.使用下划线来定义函数，对List中的每一个元素加1
a.map(_ + 1)

3.映射扁平化（flatmap）

定义

可以把flatMap，理解为先map，然后再flatten

• 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"
//获取到文本中每一行中的每一个单词，并将每一个单词都放到列表中
// 定义文本行列表
val a = List("hadoop hive spark flink flume", "kudu hbase sqoop storm")
//使用map将文本行转换为单词数组
 a.map(x=>x.split(" "))
 // 将数组中的扁平化
 a.map(x=>x.split(" ")).flatten

使用flatMap简化操作

代码示例

// 定义文本行列表
val a = List("hadoop hive spark flink flume", "kudu hbase sqoop storm")
//获取到文本中每一行中的每一个单词，并将每一个单词都放到列表中
a.flatMap(_.split(" "))

4.过滤（filter）

过滤符合一定条件的元素

方法

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

方法说明

filter方法	API	说明
参数	p: (A) ⇒ Boolean	传入一个函数对象 接收一个集合类型的参数 返回布尔类型，满足条件返回true, 不满足返回false
返回值	TraversableOnce[A]	列表

代码示例

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

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

5.是否存在（exists）

方法

def exists(p: (A) ⇒ Boolean): Boolean

方法说明

对集合中的元素进行某个判断，其中之一符合条件则返回true，反之返回false

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

//判断这个数字列表是否有小于 1 的存在
 List(1,2,3,4,5,6,7,8,9).exists(_ < 1)
 //判断这个数字列表是否有大于 1 的存在
 List(1,2,3,4,5,6,7,8,9).exists(_ > 5)

6.排序（sorted、sortBy、sortWith）

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

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

默认排序(升序) (sorted)

代码示例

//1.定义一个列表，包含以下元素: 3, 1, 2, 9, 7
//2.对列表进行升序排序
List(3,1,2,9,7).sorted

指定字段排序 (sortBy)

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

方法

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

方法说明

sortBy方法	API	说明
泛型	[B]	按照什么类型来进行排序
参数	f: (A) ⇒ B	传入函数对象 接收一个集合类型的元素参数 返回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))

自定义排序 (sortWith)

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

方法

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

方法说明

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

代码示例

//1. 有一个列表，包含以下元素：2,3,1,6,4,5
val a = List(2,3,1,6,4,5)
//2. 使用sortWith对列表进行降序排序
a.sortWith((x,y) => if(x>y)true else false)
//函数参数只在函数中出现一次，可以使用下划线代替
a.sortWith(_ > _)

7.分组（groupBy）

我们如果要将数据按照分组来进行统计分析，就需要使用到分组方法
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为这个分组字段对应的一组数据

代码示例

//有一个列表，包含了学生的姓名和性别(0代表男 1 代表女):  
//"zhangsan","0"   "lisi","1"  "wangwu","0"
//请按照性别进行分组，统计不同性别的学生人数

//定义一个元组列表来保存学生姓名和性别
val a = List("zhangsan"-> "0", "lisi"->"1", "wangwu"->"0")
//按照性别进行分组 
val b = a.groupBy(_._2)
// 将分组后的映射转换为性别/人数元组列表	
 b.map(x => x._1 -> x._2.size)

8.聚合计算（reduce）

聚合操作，可以将一个列表中的数据合并为一个。这种操作经常用来统计分析中
reduce表示将列表，传入一个函数进行聚合计算

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

方法

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

方法说明

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

代码示例

//定义一个列表，包含以下元素：1,2,3,4,5,6,7,8,9,10
val a = List(1,2,3,4,5,6,7,8,9,10)

// 第一个下划线表示第一个参数，就是历史的聚合数据结果
// 第二个下划线表示第二个参数，就是当前要聚合的数据元素
//使用reduce计算所有元素的和
a.reduce(_ + _)
// 与reduce一样，从左往右计算
a.reduceLeft(_ + _)
// 从右往左聚合计算
 a.reduceRight(_ + _)

9.折叠（fold）

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

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

方法

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,2,3,4,5,6,7,8,9,10
val a = List(1,2,3,4,5,6,7,8,9,10)
//使用fold方法计算所有元素的和
a.fold(0)(_ + _)
a.foldLeft(0)(_ + _)
a.foldRight(0)(_ + _)