函数式编程的崛起
函数式编程中的“值不可变性”避免了对公共的可变状态进行同步访问控制的复杂问题，能够较好满足分布式并行编程的需求，适应大数据时代的到来。
函数是第一等公民
- 可以作为实参传递给另外一个函数
- 可以作为返回值
- 可以赋值给变量
- 可以存储在数据结构里
def greeting() = (name: String) => { s"Hello" + " " + name }
//> greeting: ()String => String
greeting()("World") //> res0: String = Hello World
def greeting2(age: Int) = (name: String) => { s"Hello $name, your age is $age" }
//> greeting2: (age: Int)String => String
greeting2(29)("Anliven") //> res2: String = Hello Anliven, your age is 29
函数类型和值
在函数式编程中，函数的使用方式和其他数据类型的使用方式完全一致，可以像任何其他数据类型一样被传递和操作。
也就是说，可以像定义变量那样去定义一个函数，函数也会有“值”，函数的“值”就是“函数字面量（Funciton Literal）”，也称为函数文字量或函数常量。实际上，这个函数字面量其实就是一个匿名函数。
需要注意：
- Scala语法要求函数的“值”采用“=>”而不是“=”。
- 在Scala中，函数类型的格式为 A => B，表示一个接受类型A的参数，并返回类型B的函数。
def test(x: Int): Int = { x + 1 } //> test: (x: Int)Int
def test1(x: Int) = x + 1 //> test1: (x: Int)Int
val test2: Int => Int = { (x: Int) => x + 1 } //> test2 : Int => Int = testrepl$$$Lambda$8/290658609@c818063
val test3 = { (x: Int) => x + 1 } //> test3 : Int => Int = testrepl$$$Lambda$9/1057941451@75bd9247
def test5(x: Int, y: Int) = x + y //> test5: (x: Int, y: Int)Int
var test6 = (x: Int, y: Int) => x + y //> test6 : (Int, Int) => Int = testrepl$$$Lambda$10/1513712028@3cb5cdba
test6(2, 6)
示例说明：
第7行把函数"(x: Int, y: Int) => x + y"作为一个值（函数字面量）赋给test6变量。
由此可见，Scala中的函数和普通变量的使用方式完全一致。
匿名函数
使用匿名函数（Anonymous Function），可以不需要给每个函数命名，大大简化代码编写工作。
匿名函数的定义形式（也称为“Lamda表达式”）：(参数) => {表达式}
注意：如果参数只有一个，可省略参数的圆括号；如果表达式只有一行，可省略表达式的花括号。
val myNum: Int => Int = (x: Int) => { x * 2 } //> myNum : Int => Int = testrepl$$$Lambda$3/2093176254@799f7e29
val myNum2 = (x: Int) => x * 2 //> myNum2 : Int => Int = testrepl$$$Lambda$9/804581391@c818063
val myNum3: Int => Int = (x) => x * 2 //> myNum3 : Int => Int = testrepl$$$Lambda$10/1057941451@75bd9247
myNum(3) //> res0: Int = 6
myNum2(3) //> res1: Int = 6
myNum3(3) //> res2: Int = 6
def test1(x: Int): Int = { x * x } //> test1: (x: Int)Int
def test2(x: Int) = x * x //> test2: (x: Int)Int
(x: Int) => x * x //> res0: Int => Int = testrepl$$$Lambda$8/431687835@5ba23b66
val test3 = (x: Int) => x * x //> test3 : Int => Int = testrepl$$$Lambda$9/804581391@c818063
val test4: Int => Int = (x) => x * x //> test4 : Int => Int = testrepl$$$Lambda$10/1057941451@75bd9247
test1(3) //> res1: Int = 9
test2(3) //> res2: Int = 9
test3(3) //> res3: Int = 9
test4(3) //> res4: Int = 9
示例说明：
- 第1行：把匿名函数"(x: Int) => { x * 2 }"定义为一个值，赋值给myNum变量
- 第2行：省略myNum2的类型声明“Int=>Int”，省略匿名函数的表达式花括号
- 第3行：省略x的类型声明，省略匿名函数的表达式花括号
注意：类型声明“Int=>Int”和x的类型声明，不可以同时省略，因为全部省略以后，解释器也无法推断出类型。
def test1(x: Int, y: Int): Int = { x + y } //> test1: (x: Int, y: Int)Int
def test2(x: Int, y: Int) = x + y //> test2: (x: Int, y: Int)Int
(x: Int, y: Int) => x + y //> res0: (Int, Int) => Int = testrepl$$$Lambda$8/290658609@c818063
var test3 = (x: Int, y: Int) => x + y //> test3 : (Int, Int) => Int = testrepl$$$Lambda$9/1057941451@75bd9247
var test4: (Int, Int) => Int = (x, y) => { x + y }
//> test4 : (Int, Int) => Int = testrepl$$$Lambda$10/2101440631@7dc36524
test1(2, 6) //> res1: Int = 8
test2(2, 6) //> res2: Int = 8
test3(2, 6) //> res3: Int = 8
test4(2, 6) //> res4: Int = 8
闭包
闭包是一个比较特殊的函数，反映了一个从开放到封闭的过程，返回值依赖于声明在函数外部的一个或多个变量。
- 如果引用的变量是*变量，没有绑定具体的值，那么此时这个函数是“开放的”。
- 如果引用的*变量被绑定具体的值后，不再是“*变量”，从而构成一个封闭的函数，那么此时这个函数“被关闭”了。
函数引用的外部变量，必须在函数外部给出值。
闭包示例-1:
var more = 1 //> more : Int = 1
val addMore = (x: Int) => x + more //> addMore : Int => Int = testrepl$$$Lambda$9/240650537@1cd072a9
addMore(10) //> res0: Int = 11
more = 9
addMore(10) //> res1: Int = 19
示例说明：
函数定义“val addMore = (x: Int) => x + more”中，引用了没有在函数中定义的外部变量more，而more是一个*变量，还没有绑定具体的值，此时这个函数是“开放的”；而变量x是一个已在函数中明确定义的变量，只有在调用的时候才被赋值。
外部变量more确定具体值（“ var more = 1”）以后，那么函数addMore中的more变量也就被绑定具体值了，不再是“*变量”，此时这个函数是“关闭的”。
另外，每次addMore函数被调用时都会创建一个新闭包。每个闭包都会访问闭包创建时活跃的more变量。
闭包示例-2:
def plusStep(step: Int) = (num: Int) => num + step
//> plusStep: (step: Int)Int => Int
val myFunc = plusStep(3) //> myFunc : Int => Int = testrepl$$$Lambda$8/209813603@2f7c7260
println(myFunc(10)) //> 13
示例说明：
step是一个*变量，它的值只有在运行的时候才能确定，num的类型是确定的，num的值只有在调用的时候才被赋值。
这样的函数，被称为“闭包”，它反映了一个从开放到封闭的过程。
高阶函数
用函数作为形参或返回值的函数，称为高阶函数。
也就是说，高阶函数就是一个接受其他函数作为参数或者返回一个函数的函数。
高阶函数示例-1:
def f(x: Int, y: Int) = x + y //> f: (x: Int, y: Int)Int
def operate(f: (Int, Int) => Int) = { f(4, 4) } //> operate: (f: (Int, Int) => Int)Int
operate(f)
示例说明：函数operate是一个接受函数参数的函数，因此是一个高阶函数。
高阶函数示例-2:
//给定两个数区间中的所有整数求和
def sumInts(a: Int, b: Int): Int = {
if (a > b) 0 else a + sumInts(a + 1, b)
} //> sumInts: (a: Int, b: Int)Int
sumInts(1, 5) //> res0: Int = 15 //定义了一个新的函数sum，以函数f为参数
def sum(f: Int => Int, a: Int, b: Int): Int = {
if (a > b) 0 else f(a) + sum(f, a + 1, b)
} //> sum: (f: Int => Int, a: Int, b: Int)Int
//定义了一个新的函数self，该函数的输入是一个整数x，然后直接输出x自身
def self(x: Int): Int = x //> self: (x: Int)Int
//重新定义sumInts函数
def sumInts2(a: Int, b: Int): Int = sum(self, a, b)
//> sumInts2: (a: Int, b: Int)Int
sumInts2(1, 5) //> res1: Int = 15
示例说明：函数sum的参数类型是(Int=>Int, Int, Int)，结果类型是Int，也就是说函数sum是一个接受函数参数的高阶函数。
高阶函数示例-3:
def sum(f: Int => Int, a: Int, b: Int): Int = {
if (a > b) 0 else f(a) + sum(f, a + 1, b)
} //> sum: (f: Int => Int, a: Int, b: Int)Int
def self(x: Int): Int = x //> self: (x: Int)Int
def square(x: Int): Int = x * x //> square: (x: Int)Int
def powerOfTwo(x: Int): Int = if (x == 0) 1 else 2 * powerOfTwo(x - 1)
//> powerOfTwo: (x: Int)Int
def sumInts(a: Int, b: Int): Int = sum(self, a, b)
//> sumInts: (a: Int, b: Int)Int
def sumSquared(a: Int, b: Int): Int = sum(square, a, b)
//> sumSquared: (a: Int, b: Int)Int
def sumPowersOfTwo(a: Int, b: Int): Int = sum(powerOfTwo, a, b)
//> sumPowersOfTwo: (a: Int, b: Int)Int
println(sumInts(1, 5)) //> 15
println(sumSquared(1, 5)) //> 55
println(sumPowersOfTwo(1, 5)) //> 62
示例说明：
- sumInts函数：求连续整数的和
- sumSquared函数：求连续整数的平方和
- sumPowersOfTwo函数：求连续整数的关于2的幂次和
占位符语法
使用下划线作为一个或多个参数的占位符，只要每个参数在函数字面量内仅出现一次。
println("Testing, Scala!") //> Testing, Scala!
val numList = List(-3, -5, 1, 6, 9) //> numList : List[Int] = List(-3, -5, 1, 6, 9)
numList.filter(x => x > 0) //> res0: List[Int] = List(1, 6, 9)
numList.filter(_ > 0) //> res1: List[Int] = List(1, 6, 9)
示例说明：
当采用下划线的表示方法时，对于列表numList中的每个元素，都会依次传入用来替换下划线。
比如，首先传入-3，判断-3>0是否成立，是则把该值放入结果集合，否则舍弃；然后传入-5，判断-5>0是否成立，依此类推。
柯里化
柯里化函数（Curried Funciton）把具有多个参数的函数转化为一条函数链，每个节点上是单一参数。
在函数式编程中，可以基于一些通用性的函数，利用柯里化函数等来构造新函数，而不需要重新定义新函数。
示例：
def add(x: Int, y: Int) = x + y //> add: (x: Int, y: Int)Int
add(1, 2) //> res0: Int = 3 def addCurried(x: Int)(y: Int) = x + y //> addCurried: (x: Int)(y: Int)Int
addCurried(1)(2) //> res1: Int = 3 val addOne = addCurried(1)_ //> addOne : Int => Int = TestScala$$$Lambda$8/6738746@7cf10a6f
addOne(2) //> res2: Int = 3
示例说明：
函数add和addCurried的函数定义时等价的。
“addCurried(1)_”的下划线是通配后面所有的参数列表。
递归
在函数式编程中利用递归函数（Recursive Funtion）实现循环。
def factorial(n: Int): Int =
if (n <= 0) 1
else n * factorial(n - 1) //> factorial: (n: Int)Int
factorial(5) //> res0: Int = 120
尾递归
在尾递归函数（Tail Recursive Funtion）中所有递归形式的调用都出现在函数的末尾。
当编译器检测到一个函数调用时尾递归的时候，它就覆盖当前的活动记录，而不是在栈中去创建一个新的。
Scala编译器不会主动进行尾递归优化，需要“@annotation.tailrec”来 告知Scala编译器
package testscala
object TestScala {
def main(args: Array[String]) {
println("Testing, Scala!")
val res = factorial2(5, 1)
println(res)
}
@annotation.tailrec
def factorial2(n: Int, m: Int): Int =
if (n <= 0) m
else factorial2(n - 1, m * n)
}
示例：求整数a到b的相加之和
def sum(f: Int => Int)(a: Int)(b: Int): Int = {
@annotation.tailrec
def loop(n: Int)(acc: Int): Int = {
if (n > b) {
println(s"n=${n},acc=${acc}")
acc
} else {
println(s"n=${n},acc=${acc}")
loop(n + 1)(acc + f(n))
}
}
loop(a)(0)
} //> sum: (f: Int => Int)(a: Int)(b: Int)Int
sum(x => x)(1)(5) //> n=1,acc=0
//| n=2,acc=1
//| n=3,acc=3
//| n=4,acc=6
//| n=5,acc=10
//| n=6,acc=15
//| res0: Int = 15
sum(x => x * x)(1)(5) //> n=1,acc=0
//| n=2,acc=1
//| n=3,acc=5
//| n=4,acc=14
//| n=5,acc=30
//| n=6,acc=55
//| res1: Int = 55
sum(x => x * x * x)(1)(5) //> n=1,acc=0
//| n=2,acc=1
//| n=3,acc=9
//| n=4,acc=36
//| n=5,acc=100
//| n=6,acc=225
//| res2: Int = 225
val square = sum(x => x * x)_ //> square : Int => (Int => Int) = TestScala$$$Lambda$13/757108857@6bdf28bb
square(1)(5) //> n=1,acc=0
//| n=2,acc=1
//| n=3,acc=5
//| n=4,acc=14
//| n=5,acc=30
//| n=6,acc=55
//| res3: Int = 55