scala函数式编程与高阶函数

·  阅读 61
scala函数式编程与高阶函数

持续创作,加速成长!这是我参与「掘金日新计划 · 6 月更文挑战」的第1天,点击查看活动详情

一、函数式编程

谈到编程方式有指令式编程、过程化编程、函数式编程,函数式编程在使用时主要的思想就是把运算过程写成一些列嵌套的函数调用。把一组数据通过函数实现运算转化成另一组数据。函数式编程这种方式在我们将来开发Spark、Flink的业务代码时会大量使用。下面列出了一些我们经常使用的进行函数式编程的Iterable trait(可迭代特质)方法。

1、遍历 foreach

接口描述

foreach(f: (A) ⇒ Unit): Unit
Applies a function f to all elements of this immutable iterable collection
复制代码
foreachAPI说明
参数f: (A) ⇒ Unit接收一个函数对象,函数的输入参数为集合的元素,返回值为空
返回值Unit

方法示例

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

//定义一个匿名函数传入到foreach方法中;将f依次应用到集合的每个元素
scala> list.foreach((x:Int)=>println(x))
1
2
3
4

//匿名函数的输入参数的“类型”可以省略,由编译器自动推断
scala> list.foreach(x=>println(x))
1
2
3
4

//当函数有一个参数,只在函数体中出现一次,而且函数体没有嵌套调用时,可以使用下划线来简化函数定义
scala> list.foreach(println(_))
1
2
3
4

//最简写,可以直接给定println
scala> list.foreach(println)
1
2
3
4
复制代码
2、映射 map

map映射是一个一对一的映射,作为参数传入集合中每个元素,经过map传入的函数转换后输出一个元素数据。

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

示例:

//定义一个list集合,实现把内部每一个元素做乘以10,生成一个新的list集合
scala> val list=List(1,2,3,4)
list: List[Int] = List(1, 2, 3, 4)

//定义一个匿名函数
scala> list.map((x:Int)=>x*10)
res2: List[Int] = List(10, 20, 30, 40)

//省略匿名函数参数类型
scala> list.map(x=>x*10)
res3: List[Int] = List(10, 20, 30, 40)

//最简写   用下划线
scala> list.map(_*10)
res4: List[Int] = List(10, 20, 30, 40)
复制代码
3、扁平化映射 flatmap

flatmap是一个一对多的映射,作为参数传入函数的集合中的每个元素,通过flatmap的函数转化后,输出多个元素数据。

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

示例:

//定义一个List集合,每一个元素中就是一行数据,有很多个单词
scala> val list = List("hadoop hive spark flink", "hbase spark")
list: List[String] = List(hadoop hive spark flink, hbase spark)

scala> list.map(_.split(" "))
res2: List[Array[String]] = List(Array(hadoop, hive, spark, flink), Array(hbase, spark))

//flatten将多个集合的元素压到一起
scala> list.map(_.split(" ")).flatten
res3: List[String] = List(hadoop, hive, spark, flink, hbase, spark)

//等价于
//使用flatMap进行偏平化处理,获取得到所有的单词; flatMap该方法其本质是先进行了map 然后又调用了flatten
scala> list.flatMap(x => x.split(" "))
res24: List[String] = List(hadoop, hive, spark, flink, hbase, spark)

//简写
scala> list.flatMap(_.split(" "))
res25: List[String] = List(hadoop, hive, spark, flink, hbase, spark)
复制代码
4、过滤 filter

过滤符合一定条件的元素

def filter(p: (A) ⇒ Boolean): TraversableOnce[A]
复制代码
filter方法API说明
参数p: (A) ⇒ Boolean传入一个函数对象,接收一个集合类型的参数,返回布尔类型,满足条件返回true, 不满足返回false
返回值TraversableOnce[A]列表
//定义一个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)

//过滤出集合中大于5的元素
scala> list.filter(x => x >5)
res5: List[Int] = List(6, 7, 8, 9, 10)

//把集合中大于5的元素取出来乘以10生成一个新的list集合
scala> list.filter(_ > 5).map(_ * 10)
res6: List[Int] = List(60, 70, 80, 90, 100)

复制代码
5、排序 sort

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

  • sorted默认排序
  • sortBy指定字段排序
  • sortWith自定义排序
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)

//生成新的List;原List不变
scala> list
res5: List[Int] = List(5, 1, 2, 4, 3)
复制代码
2、sortBy指定字段排序

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

def sortBy[B](f: (A) ⇒ B): List[A]
复制代码
sortBy方法API说明
泛型[B]按照什么类型来进行排序
参数f: (A) ⇒ B传入函数对象,接收一个集合类型的元素参数 返回B类型的元素进行排序
返回值List[A]返回排序后的列表
```
//定义一个List集合
scala> val list=List("1 hadoop","3 flink","2 spark")
list: List[String] = List(1 hadoop, 3 flink, 2 spark)

//按照单词的首字母进行排序 scala> list.sortBy(x=>x.split(" ")(1)) res33: List[String] = List(3 flink, 1 hadoop, 2 spark)

reverse可以反转

###### 3、sortWith自定义排序

自定义排序,根据函数来定义排序规则

复制代码

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


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

复制代码

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

//降序 scala> list.sortWith((x, y)=>x>y) res35: List[Int] = List(6, 5, 4, 3, 2, 1)

list5.sortWith(_ > _)

//升序 scala> list.sortWith((x,y)=>x<y) res36: List[Int] = List(1, 2, 3, 4, 5, 6)

//字典序升序 List("Hive", "hive", "hadoop", "Spark").sortWith(.compareTo() < 0)


##### 6、分组 groupBy


首先集合的元素得是kv对的;如果要将数据按照某值分组来进行统计分析,就需要使用到分组方法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为这个分组字段对应的一组数据|

复制代码

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)

//求每个省份有多少人 val b = List("张三"->("男", "北京"), "李四"->("女", "河北"), "王五"->("男", "北京")) scala> b.groupBy(_._2._2).map(x => (x._1, x._2.size)) res14: scala.collection.immutable.Map[String,Int] = Map(北京 -> 2, 河北 -> 1)

##### 7、聚合 reduce

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

复制代码

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


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

复制代码

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) res2: Int = 55

// 第一个下划线表示第一个参数,就是历史的聚合数据结果 // 第二个下划线表示第二个参数,就是当前要聚合的数据元素 scala> a.reduce(_ + _) res3: Int = 55

// 与reduce一样,从左往右计算 scala> a.reduceLeft(_ + _) res4: Int = 55

// 从右往左聚合计算 scala> a.reduceRight(_ + _) res5: Int = 55



##### 8、折叠 fold


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

复制代码

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|列表最终折叠为一个元素|

复制代码

//定义一个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 res1: Int = 55

//给定一个初始值,,折叠求和 scala> a.fold(0)(+) res2: Int = 55

scala> a.fold(10)(+) res3: Int = 65

//从左往右 scala> a.foldLeft(10)(+) res4: Int = 65

//从右往左 scala> a.foldRight(10)(+) res5: Int = 65

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



#### 二、高阶函数

高阶函数就是使用函数值作为参数,或者返回值为函数值的“函数”和“方法“。

##### 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 =

//完整的写法 val func: Int => Int = { x => x*10 }

//函数作为参数传递到方法中 scala> array.map(func) res0: Array[Int] = Array(10, 20, 30, 40, 50)


##### 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)

//简写写法 array.map(_ * 10)


##### 3、柯里化

方法可以定义多个参数列表,当使用较少的参数列表调用多参数列表的方法时,会产生一个新的函数,该函数接收剩余的参数列表作为其参数。这被称为柯里化。

复制代码

scala> def add1(x: Int, y: Int): Int = x + y add1: (x: Int, y: Int)Int

scala> add1(1, 2) res2: Int = 3

scala> def add2(x: Int) = (y: Int) => x + y add2: (x: Int)Int => Int

scala> val func1 = add2(2) func1: Int => Int = scala> func1(3) res3: Int = 5

//直接写 scala> add2(2)(3) res4: Int = 5

//柯里化的函数写法 scala> def add3(x: Int)(y: Int) = x + y add3: (x: Int)(y: Int)Int //直接使用 scala> add3(2)(3) res6: Int = 5

//又一个示例,练习一下这多种写法 scala> def getAddress(a:String):(String,String)=>String={ | (b:String,c:String)=>a+"-"+b+"-"+c | } getAddress: (a: String)(String, String) => String

scala> val f1=getAddress("china") f1: (String, String) => String =

scala> f1("HangZhou", "xihu") res7: String = china-HangZhou-xihu

//这里也可以这样去定义方法 scala> def getAddress(a:String)(b:String,c:String): String={ | a+"-"+b+"-"+c | } getAddress: (a: String)(b: String, c: String)String

//调用 scala> getAddress("china")("HangZhou", "xihu") res3: String = china-HangZhou-xihu

scala> val func = getAddress("china") _ func: (String, String) => String =

scala> func("HangZhou", "xihu") res2: String = china-HangZhou-xihu

//向下面这些操作都是使用到了柯里化 List(1, 2, 3, 4).fold(0)(_ + ) List(1, 2, 3, 4).foldLeft(0)( + ) List(1, 2, 3, 4).foldRight(0)( + _)


##### 4、闭包

如下面示例,定义的函数func,它的返回值是依赖于不在函数作用域的一个变量,后期必须要要获取到这个变量才能执行。这种形式叫做闭包。当外部变量的值发生变化时,scala闭包也可以捕获这种变化。
复制代码

scala> var num=10 num: Int = 10

scala> val func=(x:Int) => x * num func: Int => Int =

scala> func(2) res0: Int = 20

//改变外部变量的值 scala> num = 20 num: Int = 20

scala> func(2) res1: Int = 40



复制代码
分类:
后端
收藏成功!
已添加到「」, 点击更改