概念
函数
一种具有名或匿名的操作。其代码直到被调用时才执行。在函数的定义中,可能有也可能没有引用外部的未绑定变量。
def 函数名([参数名: 参数类型],...) [: 返回值类型] = {语句[return] 返回值
}
- 函数声明的关键字是 def
- [参数名: 参数类型],…:参数列表,如果有必须给出参数类型。多个参数使用逗号分隔。如果没有形参,括号也可以省略
- [: 返回值类型] :表示函数的返回值类型,函数可以没有返回值。如果没有返回值,return不生效。只要不是递归函数,就不需要显示指定返回值类型,Scala会自动推断。
- 每行语句不用分号";“结束,写上也没错。但是单行包含多条语句,需要使用分号”;"分隔。
- return: 返回结果。 不用显示调用return,默认以最后一行结果作为返回值。如果显示的调用了return,则必须指定返回值类型。推荐不显示调用return。
- 如果函数明确声明无返回值(声明Unit),那么函数体中即使使用return关键字也不会有返回值
Lambda
一种匿名函数。在它的定义中,可能有也可能没有引用外部的未绑定变量。
闭包
是一个函数,可能匿名或具有名称,在定义中包含了自由变量,函数中包含了环境信息,以绑定其引用的自由变量。
var factor = 2
val mul = (i:Int) => i * factor
(1 to 3).map(mul) // Vector(2,4,6)
factor = 3
(1 to 3).map(mul) // Vector(3,6,9)
factor是一个自由变量,是一个当前作用域中某个值的引用。编译器创建了一个闭包,用于包含mul与它引用的外部变量的上下文信息,从而也就绑定了外部变量本身。所以mul每次调用时都重新读取factor的值。即使factor处于某个局部作用域(如某个方法)中,而我们将mul传递给其他作用域中时,这一机制仍然有效。
函数式编程
- 函数式编程把函数当做一等公民,充分利用函数,支持的函数的多种使用方式。
- “函数式编程"是一种"编程范式”(programming paradigm)。它属于"结构化编程"的一种,主要思想是把运算过程尽量写成一系列嵌套的函数调用。
- 函数式编程中,将函数也当做数据类型,因此可以接受函数当作输入(参数)和输出(返回值)。
常见函数式编程
遍历(foreach)
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))
映射(map)
map方法接收一个函数,将这个函数应用到每一个元素,返回一个新的列表
方法签名
def map[B](f: (A) ⇒ B): TraversableOnce[B]
方法解析
map | API | 说明 |
---|---|---|
泛型 | [B] | 指定map方法最终返回的集合泛型 |
参数 | f:(A) => B | 传入一个函数对象,该函数接收一个类型A(要转换的列表元素),返回值为类型B |
返回值 | TraversableOnce[B] | B类型的集合 |
map执行过程
示例
有一个列表,包含以下元素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)
可以把flatMap,理解为先map,然后再flatten。map是将列表中的元素转换为一个List,flatten再将整个列表进行扁平化。
方法签名
def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): TraversableOnce[B]
方法解析
map | API | 说明 |
---|---|---|
泛型 | [B] | 最终要转换的集合元素类型 |
参数 | f:(A) => GenTraversableOnce[B] | 传入一个函数对象,函数的参数是集合的元素,函数的返回值是一个集合 |
返回值 | TraversableOnce[B] | B类型的集合 |
flatMap执行过程
示例
有一个包含了若干个文本行的列表:“hadoop hive spark flink flume”, “kudu hbase sqoop storm”,获取到文本行中的每一个单词,并将每一个单词都放到列表中
参考代码
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)
过滤(filter)
过滤符合一定条件的元素
方法签名
def filter(f: (A) ⇒ Boolean): TraversableOnce[A]
方法解析
filter | API | 说明 |
---|---|---|
参数 | f:(A) ⇒ Boolean | 传入一个函数对象,接收一个集合类型的参数,返回布尔类型,满足条件返回true, 不满足返回false |
filter执行过程
示例
有一个数字列表,元素为: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)
是否存在(exists)
排序(sorted、sortBy、sortWith)
在scala集合中,可以使用以下几种方式来进行排序
- sorted默认排序
- sortBy指定字段排序
- sortWith自定义排序
默认排序(sorted)
示例
定义一个列表,包含以下元素: 3, 1, 2, 9, 7;对列表进行升序排序
参考代码
scala> List(3,1,2,9,7).sorted
res16: List[Int] = List(1, 2, 3, 7, 9)
指定字段排序 (sortBy)
根据传入的函数转换后,再进行排序
方法签名
def sortBy[B](f: (A) ⇒ B): List[A]
方法解析
sortBy | API | 说明 |
---|---|---|
泛型 | [B] | 按照什么类型来进行排序 |
参数 | f: (A) => B | 传入函数对象,接收一个集合类型的元素参数,返回B类型的元素进行排序 |
返回值 | List[A] | 返回排序后的列表 |
示例
有一个列表,分别包含几下文本行:“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)
自定义排序,根据一个函数来进行自定义排序
方法签名
def sortWith(f: (A, A) ⇒ Boolean): List[A]
方法解析
sortWith | API | 说明 |
---|---|---|
参数 | f: (A, A) ⇒ Boolean | 传入一个比较大小的函数对象,接收两个集合类型的元素参数,返回两个元素大小,小于返回true,大于返回false |
返回值 | List[A] | 返回排序后的列表 |
示例
有一个列表,包含以下元素:2,3,1,6,4,5,使用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]]
方法解析
groupBy | API | 说明 |
---|---|---|
泛型 | [K] | 分组字段的类型 |
参数 | f: (A) ⇒ K | 传入一个函数对象,接收集合元素类型的参数,返回一个K类型的key,这个key会用来进行分组,相同的key放在一组中 |
返回值 | Map[K, List[A]] | 返回一个映射,K为分组字段,List为这个分组字段对应的一组数据 |
groupBy执行过程
示例
定义一个元组列表来保存学生姓名和性别 【“张三”, “男”,“李四”, “女”,“王五”, “男”】,按照性别进行分组,将分组后的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)
聚合操作,可以将一个列表中的数据合并为一个。这种操作经常用来统计分析中
方法签名
def reduce[A1 >: A](f: (A1, A1) ⇒ A1): A1
方法解析
reduce | API | 说明 |
---|---|---|
泛型 | [A1 >: A] | (下界)A1必须是集合元素类型的子类 |
参数 | f: (A1, A1) ⇒ A1 | 传入函数对象,用来不断进行聚合操作,第一个A1类型参数为:当前聚合后的变量,第二个A1类型参数为:当前要进行聚合的元素 |
返回值 | A1 | 列表最终聚合为一个元素 |
reduce执行过程
- reduce和reduceLeft效果一致,表示从左到右计算
- reduceRight表示从右到左计算
示例
定义一个列表,包含以下元素: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)(f: (A1, A1) ⇒ A1): A1
方法解析
reduce | API | 说明 |
---|---|---|
泛型 | [A1 >: A] | (下界)A1必须是集合元素类型的子类 |
参数1 | z: A1 | 初始值 |
参数2 | f: (A1, A1) ⇒ A1 | 传入函数对象,用来不断进行聚合操作,第一个A1类型参数为:当前折叠后的变量,第二个A1类型参数为:当前要进行折叠的元素 |
返回值 | A1 | 列表最终折叠为一个元素 |
- fold和foldLet效果一致,表示从左往右计算
- foldRight表示从右往左计算
示例
定义一个列表,包含以下元素: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 = 55