本节主要内容
（一）函数字面量（值函数）
（二）匿名函数
（三）函数的简化
（四）函数参数
（四）闭包
函数字面量（值函数）
函数字面量（function literal），也称值函数（function values），指的是函数可以赋值给变量。
一般函数具有如下形式：
而函数字面量具有如下形式：
/*
函数字面量
function literal
=>左侧的表示输入，右侧表示转换操作
*/
scala> val
increase=(x:Int)=>x+
1
increase: Int
=> Int = <function1>
scala> println(increase(
10))
11
scala> def increaseAnother(x:Int)=x
+1
increaseAnother: (x: Int)Int
scala>
println(increaseAnother
(10))
11
val increase2=(x:Int)=>{
println(
"Xue")
println(
"Tu")
println(
"Wu")
println(
"You")
x
+1
}
scala>
println(increase2
(10))
Xue
Tu
Wu
You
11
scala>
println(Array
(1,2,3,4).
map(increase).mkString(
","))
2,3,4,5
匿名函数
//匿名函数写法（写法
2）
scala>println
(Array(1,2,3,4).map((x:Int)=>x+1).mkString(","))
2,3,4,5
函数进一步简化
//花括方式（写法
3）
scala> Array
(1,2,3,4).map{(x:Int)=>x+
1}.mkString(
",")
res25: String =
2,
3,
4,
5
//省略.的方式（写法
4)
scala> Array
(1,2,3,4) map{(x:Int)=>x+
1} mkString(
",")
res26: String =
2,
3,
4,
5
//参数类型推断写法（写法
5）
scala> Array
(1,2,3,4) map{(x)=>x+
1} mkString(
",")
res27: String =
2,
3,
4,
5
//函数只有一个参数的话，可以省略()（写法
6）
scala> Array(
1,
2,
3,
4) map{x=>x+
1} mkString(
",")
res28: String =
2,
3,
4,
5
//如果参数右边只出现一次，则可以进一步简化（写法
7）
scala> Array(
1,
2,
3,
4) map{_+
1} mkString(
",")
res29: String =
2,
3,
4,
5
//值函数简化方式
//val fun0=
1+_，该定义方式不合法，因为无法进行类型推断
scala> val fun0=
1+_
<
console>:
10:
error: missing parameter type
for expanded
function ((x$1) => 1
x$1))
//值函数简化方式（正确方式）
scala> val fun1=1+(_:Double)
un1: Double => Double = <function1>
scala> fun1(
999)
es30: Double =
1000.0
//值函数简化方式（正确方式
2）
scala> val
fun2:
(Double)=>Double=
1+_
fun2: Double
=> Double = <function1>
scala> fun2(
200)
res31: Double =
201.0
函数参数
//函数参数(高阶函数）
//((Int)=>String)=>String
scala> def convertIntToString
(f:(Int)=>String)=f(4)
convertIntToString: (f: Int => String)String
scala> convertIntToString((x:Int)=>x+" s")
res32: String = 4 s
//高阶函数可以产生新的函数
//(Double)=>((Double)=>Double)
scala> def multiplyBy(factor:Double)=(x:Double)=>factor*x
multiplyBy: (
factor: Double)Double
=> Double
scala> val x=multiplyBy(
10)
x: Double
=> Double = <function1>
scala> x(
50)
res33: Double =
500.0
函数闭包
//闭包(Closure）
//(x:Int)=>x+more,这里面的more是一个自由变量（Free Variable）,more是一个没有给定含义的不定变量
//而x则的类型确定、值在函数调用的时候被赋值，称这种变量为绑定变量（Bound Variable）
scala>
(x:Int)=>x+more
<
console>:
8:
error:
not found: value more
(x:Int)=>x+more
^
scala>
var more=
1
more: Int =
1
scala>val
fun=(x:Int)=>x+more
fun: Int
=> Int = <function1>
scala> fun(
10)
res1: Int =
11
scala> more=
10
more: Int =
10
scala> fun(
10)
res2: Int =
20
//像这种运行时确定more类型及值的函数称为闭包,more是个自由变量，在运行时其值和类型得以确定
//这是一个由开放(free)到封闭的过程，因此称为闭包
scala> val someNumbers = List(-
11, -
10, -
5,
0,
5,
10)
someNumbers: List[Int] = List(-
11, -
10, -
5,
0,
5,
10)
scala>
var sum =
0
sum: Int =
0
scala> someNumbers.foreach(sum += _)
scala> sum
res8: Int = -
11
scala> someNumbers.foreach(sum += _)
scala> sum
res10: Int = -
22
//下列函数也是一种闭包，因为在运行时其值才得以确定
def multiplyBy
(factor:Double)=(x:Double)=>factor*x
添加公众微信号，可以了解更多最新Spark、Scala相关技术资讯
