2023_Spark_实验七：Scala函数式编程部分演示

1、Scala中的函数

在Scala中，函数是“头等公民”，就和数字一样。可以在变量中存放函数，即：将函数作为变量的值（值函数）。

def myFun1(name:String):String="Hello " + name
 
println(myFun1("Tom"))
 
 
 
def myFun2():String = "Hello World"
 
 
 
//值函数：将函数作为变量的值
 
val v1 = myFun1("Tom")
 
val v2 = myFun2()
 
//再将v1 付给myFun1(v1)
 
println(myFun1(v1))

2、匿名函数

 
//匿名函数
 
(x:Int) => x*3
 
//例子：（1,2,3）---》（3,6,9）
 
Array(1,2,3).map((x:Int) => x*3)
 
//由于map方法接收一个函数参数，我就就可以把上面的匿名函数作为参数传递给map方法

3、带函数参数的函数，即：高阶函数

示例1：

（*）首先，定义一个最普通的函数

（*）再定义一个高阶函数

（*）分析这个高阶函数调用的过程

 
//定义一个最普通的函数
 
def fun1(name:String):String = "Hello "+ name
 
 
 
import scala.math._
 
//定义高阶函数：带有函数参数的函数
 
def someAction(f:(Double) => Double) =f(10)
 
//测试
 
someAction(sqrt)

示例2：

//另外一个例子
 
def mytest(x:Int,y:Int) :Int ={x*y + 100}
 
 
 
//定义一个高阶函数
 
 
 
def myFunction(f:(Int,Int) =>Int,x:Int,y:Int) = f(x,y)
 
//测试
 
myFunction(mytest,1,2)

在这个例子中，首先定义了一个普通的函数mytest，然后定义了一个高阶函数myFunction；myFunction接收三个参数：第

一个f是一个函数参数，第二个是x，第三个是y。而f是一个函数参数，本身接收两个Int的参数，返回一个Int的值。

4、闭包

就是函数的嵌套，即：在一个函数定义中，包含另外一个函数的定义；并且在内函数中可以访问外函数中的变量。

测试上面的函数：

 
def mulBy(factor:Double)=(x:Double)=>x*factor
 
//变量
 
val triple = mulBy(3) //表示乘以3倍的操作
 
val half = mulBy(0.5) //表示除以2倍的操作
 
 
 
//调用
 
 
 
println(triple(10)+ " " + half(8))

5、柯里化：Currying

柯里化函数(Curried Function)是把具有多个参数的函数转换为一条函数链，每个节点上是单一参数。

一个简单的例子：

 
//柯里化
 
//一个普通的函数
 
def mulByOneTime(x:Int,y:Int) = x + y
 
 
 
//柯里化函数
 
 
 
def mulByOneTime1(x:Int) =(y:Int) =>x * y
 
 
 
//简写的方式
 
def mulByOneTime2(x:Int)(y:Int)= x * y
 
//测试
 
mulByOneTime(6,7)
 
mulByOneTime1(6)(7)
 
mulByOneTime2(6)(7)

6、高阶函数示例

示例1：

//map
 
//在列表中的每个元素上计算一个函数，并且返回一个包含相同数目元素的列表
 
val numbers = List(1,2,3,4,5,6,7,8,9,10)
 
numbers.map((i:Int)=>i*2)

示例2：

//foreach
 
//foreach 和 map 相似 ，只不过它没有返回值，foreach只要是为了对参数进行作用
 
val numbers = List(1,2,3,4,5,6,7,8,9,10)
 
numbers.foreach((i:Int)=>i*2)

示例3：

//filter
 
//移除任何使得传入的函数返回false的元素
 
val numbers = List(1,2,3,4,5,6,7,8,9,10)
 
numbers.filter((i:Int) => i%2==0)

示例4

 
//zip
 
//zip把两个列表的元素合成一个由元素对组成的列表里
 
List(1,2,3).zip(List(4,5,6,7))

示例5：

 
//partition
 
//partition根据断言函数的返回值对列表进行拆分
 
val numbers = List(1,2,3,4,5,6,7,8,9,10)
 
numbers.partition((i:Int) =>i%2==0)

在这个例子中，可以被2整除的被分到一个分区；不能被2整除的被分到另一个分区。

示例6：

 
//find
 
//find返回集合里第一个匹配断言函数的元素
 
val numbers = List(1,2,3,4,5,6,7,8,9,10)
 
numbers.find(_ % 3 ==0)

示例7：

 
//flatten
 
//flatten可以把嵌套的结构展开
 
List(List(1,2,3),List(4,5,6)).flatten

示例8：

//flatMap
 
//flatMap 是一个常用的combinator,它结合了map 和 flatten的功能
 
val myList = List(List(1,2,3),List(4,5,6))
 
myList.flatMap(x => x.map(_ * 2))

在这个例子中，分为两步：

1. 将(1,2,3)和(4,5,6)这两个集合合并成一个集合

2. 再对每个元素乘以2