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