scala之函数式编程及高阶函数
1、 函数式编程使用Spark/Flink的大量业务代码都会使用到函数式编程。1.1 遍历 - foreach(1)方法描述foreach(f: (A) ⇒ Unit): Unit(2)方法说明foreachAPI说明参数f: (A) ⇒ Unit...
目录
1、 函数式编程
- 使用Spark/Flink的大量业务代码都会使用到函数式编程。
1.1 遍历 - foreach
(1)方法描述
foreach(f: (A) ⇒ Unit): Unit
(2)方法说明
foreach | API | 说明 |
参数 | f: (A) ⇒ Unit | 接收一个函数对象作为参数; 函数的输入参数为集合的元素; 返回值为空。 |
返回值 | Unit | 空 |
(3)实战演练
(1)先定义一个list列表
scala> val list = List(1, 2, 3, 4)
list: List[Int] = List(1, 2, 3, 4)
(2)定义一个匿名函数传入到foreach方法中
scala> list.foreach((x: Int) => println(x))
1
2
3
4
(3)匿名函数的输入参数类型可以省略,由编译器自动推断
scala> list.foreach(x => println(x))
1
2
3
4
(4)当函数参数,只在函数体中出现一次,而且函数体没有嵌套调用时,可以使用下划线来简化函数定义
scala> list.foreach(println(_))
1
2
3
4
(5)最简写,直接给定println
scala> list.foreach(println)
1
2
3
4
1.2 映射 - map
(1)方法描述
def map[B](f: (A) ⇒ B): TraversableOnce[B]
(2)方法说明
map方法 | API | 说明 |
泛型 | [B] | 指定map方法最终返回的集合泛型 |
参数 | f: (A) ⇒ B | 传入一个函数对象作为参数; 该函数接收一个类型A(要转换的集合的元素类型); 返回值为类型B |
返回值 | TraversableOnce[B] | B类型的集合 |
(3)实战演练
//实现把内部每一个元素做乘以10,生成一个新的list集合
(1)定义一个匿名函数
scala> list.map((x: Int) => x * 10)
res21: List[Int] = List(10, 20, 30, 40)
(2)省略匿名函数参数类型
scala> list.map(x => x * 10)
res22: List[Int] = List(10, 20, 30, 40)
(3)最简写用下划线
scala> list.map(_ * 10)
res23: List[Int] = List(10, 20, 30, 40)
1.3 扁平化映射 - flatmap
(1)方法描述
def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): TraversableOnce[B]
(2)方法说明
flatmap方法 | API | 说明 |
泛型 | [B] | 最终要转换的集合元素类型 |
参数 | f: (A) ⇒ GenTraversableOnce[B] | 传入一个函数对象作为参数; 函数的参数是集合的元素; 函数的返回值是一个集合 |
返回值 | TraversableOnce[B] | B类型的集合 |
(3)实战演练
(1)定义一个List集合,每一个元素中就是一行数据,有很多个单词
scala> val list = List("hadoop hive spark flink", "hbase spark")
list: List[String] = List(hadoop hive spark flink, hbase spark)
(2)使用flatMap进行偏平化处理,获取得到所有的单词
scala> list.flatMap(x => x.split(" "))
res24: List[String] = List(hadoop, hive, spark, flink, hbase, spark)
(3)简写
scala> list.flatMap(_.split(" "))
res25: List[String] = List(hadoop, hive, spark, flink, hbase, spark)
(4)flatMap该方法其本质是先进行了map 然后又调用了flatten
scala> list.map(_.split(" ")).flatten
res26: List[String] = List(hadoop, hive, spark, flink, hbase, spark)
1.4 过滤 - filter
过滤符合一定条件的元素。
(1)方法描述
def filter(p: (A) ⇒ Boolean): TraversableOnce[A]
(2)方法说明
filter方法 | API | 说明 |
参数 | p: (A) ⇒ Boolean | 传入一个函数对象作为参数; 函数的参数是集合中的元素; 此函数返回布尔类型,满足条件返回true, 不满足返回false |
返回值 | TraversableOnce[A] | 列表 |
(3)实战演练
(1)定义一个list集合
scala> val list = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
list: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
(2)过滤出集合中大于5的元素
scala> list.filter(x => x > 5)
res27: List[Int] = List(6, 7, 8, 9, 10)
(3)把集合中大于5的元素取出来乘以10生成一个新的list集合
scala> list.filter(_ > 5).map(_ * 10)
res29: List[Int] = List(60, 70, 80, 90, 100)
1.5 排序 - sort
在scala集合中,可以使用以下几种方式来进行排序:
(1)sorted默认排序(升序)
//定义一个List集合
scala> val list = List(5, 1, 2, 4, 3)
list: List[Int] = List(5, 1, 2, 4, 3)
//默认就是升序
scala> list.sorted
res30: List[Int] = List(1, 2, 3, 4, 5)
(2)sortBy指定字段排序:根据传入的函数转换后,再进行排序
1)方法描述
sortBy[B](f: (A) ⇒ B): List[A]
2)方法说明
sortBy方法 | API | 说明 |
泛型 | [B] | 按照什么类型来进行排序 |
参数 | f: (A) ⇒ B | 传入函数对象作为参数; 函数接收一个集合类型的元素为参数; 返回B类型的元素进行排序。 |
返回值 | List[A] | 返回排序后的列表 |
3)实战演练
(1)定义一个List集合
scala> val list = List("1 hadoop", "2 spark", "3 flink")
list: List[String] = List(1 hadoop, 2 spark, 3 flink)
(2)按照单词的首字母进行排序
scala> list.sortBy(x => x.split(" ")(1))
res33: List[String] = List(3 flink, 1 hadoop, 2 spark)
(3)sortWith自定义排序:自定义排序,根据一个函数来进行自定义排序
1)方法描述:
def sortWith(lt: (A, A) ⇒ Boolean): List[A]
2)方法说明
sortWith方法 | API | 说明 |
参数 | lt: (A, A) ⇒ Boolean | 传入一个比较大小的函数对象作为参数; 函数接收两个集合类型的元素作为参数; 返回两个元素大小,小于返回true,大于返回false。 |
返回值 | List[A] | 返回排序后的列表 |
3)实战演练:
val list = List(2, 3, 1, 6, 4, 5)
a: List[Int] = List(2, 3, 1, 6, 4, 5)
(1)降序
scala> list.sortWith((x, y) => x > y)
res35: List[Int] = List(6, 5, 4, 3, 2, 1)
//简写
scala> list.sortWith(_ > _)
(2)升序
scala> list.sortWith((x, y) => x < y)
res36: List[Int] = List(1, 2, 3, 4, 5, 6)
//升序 简写
scala> list.sortWith(_ < _)
1.6 分组 - groupBy
我们如果要将数据按照分组来进行统计分析,就需要使用到分组方法;
groupBy表示按照函数将列表分成不同的组。
(1)方法描述
def groupBy[K](f: (A) ⇒ K): Map[K, List[A]]
(2)方法说明
groupBy方法 | API | 说明 |
泛型 | [K] | 分组字段的类型 |
参数 | f: (A) ⇒ K | 传入一个函数对象作为参数; 函数接收集合元素作为参数; 返回一个K类型的key,这个key会用来进行分组,相同的key放在一组中 |
返回值 | Map[K, List[A]] | 返回一个映射,K为分组字段,List为这个分组字段对应的一组数据 |
(3)实战演练
scala> val a = List("张三" -> "男", "李四" -> "女", "王五" -> "男")
a: List[(String, String)] = List((张三,男), (李四,女), (王五,男))
// 按照性别分组(即键值对第二个值)
scala> a.groupBy((kv: (String, String)) => {kv._2})
//简写
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)
1.7 聚合 - reduce
将列表传入一个函数进行聚合计算。
(1)方法描述
def reduce[A1 >: A](op: (A1, A1) ⇒ A1): A1
(2)方法说明
reduce方法 | API | 说明 |
泛型 | [A1 >: A] | (下界)A1必须是集合元素类型的子类 |
参数 | op: (A1, A1) ⇒ A1 | 传入函数对象,用来不断进行聚合操作; 第一个A1类型参数为:当前聚合后的变量; 第二个A1类型参数为:当前要进行聚合的元素 |
返回值 | A1 | 列表最终聚合为一个元素 |
(3)实战演练
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
1.8 折叠 - fold
fold与reduce很像,但是多了一个指定初始值参数。
(1)方法描述:
def fold[A1 >: A](z: A1)(op: (A1, A1) ⇒ A1): A1
(2)方法说明
reduce方法 | API | 说明 |
泛型 | [A1 >: A] | (下界)A1必须是集合元素类型的子类 |
参数1 | z: A1 | 初始值 |
参数2 | op: (A1, A1) ⇒ A1 | 传入函数对象,用来不断进行折叠操作; 第一个A1类型参数为:当前折叠后的变量; 第二个A1类型参数为:当前要进行折叠的元素 |
返回值 | A1 | 列表最终折叠为一个元素 |
(3)实战演练
//定义一个List集合
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.sum
res41: Int = 55
//给定一个初始值,,折叠求和
scala> a.fold(0)(_ + _)
res42: Int = 55
scala> a.fold(10)(_ + _)
res43: Int = 65
//从左往右
scala> a.foldLeft(10)(_ + _)
res44: Int = 65
//从右往左
scala> a.foldRight(10)(_ + _)
res45: Int = 65
//fold和foldLet效果一致,表示从左往右计算
//foldRight表示从右往左计算
2、 高阶函数
使用函数值作为参数,或者返回值为函数值的“函数”和“方法”,均称之为“高阶函数”。
2.1 函数值作为参数
//定义一个数组
scala> val array = Array(1, 2, 3, 4, 5)
array: Array[Int] = Array(1, 2, 3, 4, 5)
//定义一个函数
scala> val func = (x: Int) => x * 10
func: Int => Int = <function1>
//函数作为参数传递到方法中
scala> array.map(func)
res0: Array[Int] = Array(10, 20, 30, 40, 50)
2.2 匿名函数
//定义一个数组
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)
2.3 柯里化
方法可以定义多个参数列表,当使用较少的参数列表调用多参数列表的方法时,会产生一个新的函数,该函数接收剩余的参数列表作为其参数。这被称为柯里化。
def getAddress(a: String): (String, String) => String = {
(b: String,c: String) => a + "-" + b + "-" + c
}
scala> val f1 = getAddress("china")
f1: (String, String) => String = <function2>
scala> f1("beijing","tiananmen")
res5: String = china-beijing-tiananmen
//这里就可以用柯里化去定义方法
def getAddress(a: String)(b: String,c: String): String = {
a + "-" + b + "-" + c
}
//调用
scala> getAddress("china")("beijing", "tiananmen")
res0: String = china-beijing-tiananmen
scala> val func1 = getAddress("a") _
scala> func1("c", "d")
res117: String = a-c-d
//之前的这些操作就是使用到了柯里化
List(1,2,3,4).fold(0)(_ + _)
List(1,2,3,4).foldLeft(0)(_ + _)
List(1,2,3,4).foldRight(0)(_ + _)
2.4 闭包
函数里面引用外面类成员变量叫作闭包。
scala> var factor = 1
factor: Int = 1
scala> val f1 = (x: Int) => x * factor
f1: Int => Int = <function1>
scala> f1(2)
res5: Int = 2
scala> factor = 5
factor: Int = 5
scala> f1(2)
res6: Int = 10
//定义的函数f1,它的返回值是依赖于不在函数作用域的一个变量
//后期必须要要获取到这个变量才能执行
//spark和flink程序的开发中大量的使用到函数,函数的返回值依赖的变量可能都需要进行大量的网络传输获取得到。需要这些变量实现序列化进行网络传输。
def multiply(x: Double) = (y: Double) => x * y
val doubleFunc = multiply(2)
val tripleFunc = multiply(3)
doubleFunc(10)
tripleFunc(10)
更多推荐
所有评论(0)