scala函数式编程语法小结

• 遍历|foreach
  使用foreach的方法来进行遍历，迭代会让代码更加简洁

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

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

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

参考代码

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

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

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

1. 有一个列表,包含以下元素1,2,3,4 请使用foreach方法遍历打印每个元素
2. 使用类型推断简化函数定义
   参考代码:

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

scala> a.foreach(x=>println(x))

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

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

示例:

1. 有一个列表,包含以下元素1,2,3,4,请使用foreach方法遍历打印每个元素
2. 请使用下划线简化函数定义

参考代码:

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

scala> a.foreach(println(_))

• 如果方法参数是函数,如果出现了下划线,scala编译器会自动代码封装到一个函数中

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

• 映射|map
  集合的映射操作是将来在编写Spark/Flink用的最多的操作,是我们必须掌握的,因为进行数据计算的时候,就是一个将一种数据类型转换为另一种数据类型的过程

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

用法:

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

方法解析

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

map方法解析

示例一:

1. 创建一个列表,包含元素1,2,3,4
2. 对List中的每一个元素加1
   参考代码:

scala> a.map(x=>x+1)
res9: List[Int] = List(2, 3, 4, 5)

示例二:

1. 创建一个列表,包含1,2,3,4
2. 使用下划线来定义函数,堆List中的每一个元素加1
   参考代码:

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

scala> a.map(_+1)
res10: List[Int] = List(2, 3, 4, 5)

• 扁平化映射|flatMap
  扁平化映射也是将来用得非常多的操作,也是必须掌握的

定义:可以吧flatMap,理解为先map,然后在flatten

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

方法签名

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

方法解析

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

示例:

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

思路分析:

参考代码:

//定义文本行列表
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(" "))
res11: List[Array[String]] = List(Array(hadoop, hive, spark, flink, flume), Array(kudu, hbase, sqoop, storm))

//扁平化
scala> a.map(x=>x.split(" ")).flatten
res12: 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(" "))
res13: List[String] = List(hadoop, hive, spark, flink, flume, kudu, hbase, sqoop, storm)

• 过滤|filter

过滤符合一定条件的元素

方法签名:

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

方法解析:

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

示例:

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

参考代码:

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

• sorted(默认排序)
  示例:

1. 定义一个列表,包含以下元素:3,1,2,6,7
2. 对列表进行排序

参考代码:

//升序
scala> List(3,1,2,6,7).sorted
res15: List[Int] = List(1, 2, 3, 6, 7)
//降序
scala> List(3,1,2,6,7).sorted.reverse
res16: List[Int] = List(7, 6, 3, 2, 1)

• 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. 请按照单子的字母进行排序

参考代码:

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))
res21: List[String] = List(02 flume, 01 hadoop, 03 hive, 04 spark)

• 自定义排序|sortWith
  自定义排序,根据一个函数来进行自定义排序

方法签名:

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

方法解析:

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

示例:

1. 有一个列表,包含以下的元素:2,3,1,6,5,4
2. 使用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)
res22: List[Int] = List(1, 2, 3, 4, 5, 6)

使用下划线简写:

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

scala> a.sortWith(_<_)
res0: List[Int] = List(1, 2, 3, 4, 5, 6)

• 分组|group
  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执行过程分析

示例:

1. 有一行列表,包含了学生的姓名和性别:

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

2. 请按照性别进行分组,统计不同性别的学生人数
   参考代码:

//1.定义一个元组列表来保存学生的姓名和性别
//2.按照性别进行分组,将分组后的Map转换为列表
scala> val a = List("张三"->"男", "李四"->"女", "王五"->"男")
a: List[(String, String)] = List((张三,男), (李四,女), (王五,男))

scala> a.groupBy(_._2).map(x=>x._1->x._2.size)
res40: scala.collection.immutable.Map[String,Int] = Map(男 -> 2, 女 -> 1):List(("男"->2),("女"->1))

-聚合操作|reduce
将一个列表中的数据合并为一个,

方法标签:

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

方法解析:

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

reduce的执行流程

• reduce的和reduceLeft效果一样,表示从左到右的计算
• reduceRight表示从右到左的计算

案例:

1. 定义一个列表,包含以下元素:1,2,3,4,5,6,7,8,9,10
2. 使用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)
res41: Int = 55

//第一个下划线表示第一个参数,就是历史的聚合数据结果
//第二个下划线表示第二个参数,就是当前要聚合的数据元素
scala> a.reduce(_+_)
res42: Int = 55
//与reduce一样,从左往右计算
scala> a.reduceLeft(_+_)
res43: Int = 55
//从右往左进行聚合减计算
scala> a.reduceRight(_-_)
res44: Int = -5

• 折叠|flod
  flod和reduce很像,但是多个一个初始值参数
  案例:

1. 定义一个列表,包含以下元素:1,2,3,4,5,6,7,8,9,10
2. 使用flod方法计算所有元素的和
   参考代码:

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)(_+_)
res46: Int = 55