引言

Scala是一门既面向对象，又面向过程的语言，Scala的函数式编程，就是Scala面向过程最好的佐证。也真是因此让Scala具备了Java所不具备的更强大的功能和特性。

而之所以Scala一直没有替代Java，一是因为Java诞生早，基于Java开发了大量知名的工程，并且最重要的是Java现在不只是一门编程语言，而是一个庞大的技术生态圈，所以未来十年内Scala也不会完全替代Java，但是Scala会在自己特有的领域大发光彩。

将函数赋值给变量

Scala中函数是一等公民，可以独立定义，独立存在，而且可以直接将函数作为值赋值给变量。

Scala语法规定：将函数赋值给变量时，必须在函数后加上空格和下划线

scala> def sayHello(name: String) = println("hello, " + name) 
sayHello: (name: String)Unit 

// 必须在函数后加上空格和下划线 
scala> val sayHelloFunc = sayHello _ 
sayHelloFunc: String => Unit = <function1> 
 
scala> sayHelloFunc("sparks") 
hello, sparks 

匿名函数

可以直接定义匿名函数并赋值给某个变量；也可以将匿名函数传入其他函数之中。

Scala定义匿名函数的语法规则是，（参数名: 参数类型） => {函数体}

匿名函数在Spark源码中有大量使用。

scala> val sayHelloFunc = (name: String) => {println("hello, "+name)} 
sayHelloFunc: String => Unit = <function1> 
 
scala> sayHelloFunc("sparks") 
hello, sparks 

高阶函数

在Scala中，由于函数时一等公民，因此可以直接将某个函数传入其他函数，作为参数。这个功能是极其强大的，也是Java这种面向对象的编程语言所不具备的。

接收其他函数作为参数的函数，也被称为高阶函数（higher-order function)

scala> val sayHelloFunc = (name: String) => println("hello, "+name) 
 

// 接收函数作为参数 
scala> def greeting(func: (String)=> Unit, name: String){func(name)} 
 

// 将匿名函数当做参数传入 
scala> greeting(sayHelloFunc, "leo") 
hello, leo 
 

// Array的map函数也是高阶函数 
scala> Array(1,2,3,4,5).map((num: Int) => num*num) 
res5: Array[Int] = Array(1, 4, 9, 16, 25) 
 

// 高阶函数的另外一个功能是将函数作为返回值 
scala> def getGreetingFunc(msg: String) = (name: String) => println(msg + " " + name) 
 
scala> val greetingFunc = getGreetingFunc("hello") 
 
scala> greetingFunc("sparks") 
hello sparks 

高阶函数-类型推断（更易阅读）

在高阶函数中，经常将只需要执行一次的函数定义为匿名函数作为参数传递给高阶函数，就好像map()、filter()等高阶函数中经常能看到使用了匿名函数作为参数。匿名函数在这里有一个特性能够帮助我们写出更容易阅读的函数——参数推断。 
正常情况下，我们使用匿名函数的方式如下：

object Test { 
  def main(args: Array[String]) { 
    val arr = Array(1.23, 34.1, 21.32) 
    val result = arr.map((a: Double) => a * 3) 
    println(result.mkString(" ")) 
  } 
} 

即在map函数中定义匿名函数(a: Double) => a * 3，但是由于map函数知道你传入的是一个类型为(Double)=> Double类型的函数，故可以简化为

object Test { 
  def main(args: Array[String]) { 
    val arr = Array(1.23, 34.1, 21.32) 
    val result = arr.map((a) => a * 3) 
    println(result.mkString(" ")) 
  } 
} 

并且如果匿名函数只有一个参数，则可以省略()，继续简化：

object Test { 
  def main(args: Array[String]) { 
    val arr = Array(1.23, 34.1, 21.32) 
    val result = arr.map(a => a * 3) 
    println(result.mkString(" ")) 
  } 
} 

在此基础上，如果参数在=>右边只出现了一次，则可以用_替换它（Spark中大量使用了这种语法）：

object Test { 
  def main(args: Array[String]) { 
    val arr = Array(1.23, 34.1, 21.32) 
    val result = arr.map(_ * 3) 
    println(result.mkString(" ")) 
  } 
} 

  
类似的示例：

// 定义该函数参数接收Int参数，返回Int值 
scala> def triplt(func: (Int) => Int) = {func(3)} 

// 3作为该匿名参数的唯一参数与6做了相乘，然后返回 

// 相当于triplt((a: Int) => a * 6) 
scala> triplt(_ * 6) 
res17: Int = 18 
 
scala> triplt(_ + 6) 
res18: Int = 9 

常见的高阶函数

1. map：对传入集合的每个元素进行映射，返回每个元素处理后的集合。

scala> Array(3,4,1,5,2).map(2 * _) 
res23: Array[Int] = Array(6, 8, 2, 10, 4) 

2. foreach：对传入的每个元素都进行处理，但是没有返回值。

scala> (1 to 9).map("*" * _).foreach(println _) 
* 
** 
*** 
**** 
***** 
****** 
******* 
******** 
********* 

3. filter：对传入的每个元素都进行条件判断，保留True元素。

scala> (1 to 20).filter(_ % 2 == 0) 
res20: scala.collection.immutable.IndexedSeq[Int] = Vector(2, 4, 6, 8, 10, 12, 14, 16, 18, 20) 

4. reduceLeft：从左侧开始，即先对参数0和参数1进行处理，然后将结果与元素2处理，再将结果与元素3处理，一次类推，即为reduce；（Spark编程的重点！）

// 相当于1 * 2 * 3 *……* 9 
scala> (1 to 9).reduceLeft(_ * _) 
res21: Int = 362880 

5. 对元素进行两两比较，排序

scala> Array(3,4,1,5,2).sortWith(_ < _) 
res22: Array[Int] = Array(1, 2, 3, 4, 5) 

闭包

函数在变量不处于其有效作用域时，还能够对变量进行访问，即为闭包

scala> def getGreetingFunc(msg: String) = (name: String) => println(msg + ", " + name) 
 
scala> val greetingFuncHello = getGreetingFunc("hello") 
 
scala> val greetingFuncHi = getGreetingFunc("hi") 
 
scala> greetingFuncHello("sparks") 
hello, sparks 
 
scala> greetingFuncHi("sparks") 
hi, sparks 

在上面的getGreetingFunc函数中，msg只是一个局部变量，却在getGreetingFunc执行完后，还可以继续存在创建的函数之中。

greetingFuncHello(“sparks”)运行时，还值为hello的msg被保留在了函数体内部，可以反复使用。 
这种变量超出了其作用域，还能够对变量进行访问，即为闭包。

原理

Scala通过为每个函数创建对象来时间闭包，实际上对于greetingFunc函数创建的函数，msg是作为函数对象的变量存在的，因此每个函数才可以拥有不同msg。

SAM转换

在Java中，不支持直接将函数当做参数传入方法，唯一的办法就是定义一个实现了某个接口的类的实例对象，该对象只有一个方法；而这些接口都只有单个的抽象方法，也就是single abstract method， 简称为SAM

由于Scala是可以调用Java代码的，因为当我们调用Java的某个方法时，可能就不得不创建SAM传递给方法，非常麻烦；但是Scala又是支持直接传递函数的，此时就可以使用Scala提供的隐式转换特性将SAM转化为Scala函数。

import javax.swing._ 

import java.awt.event._ 

// 标准的JAVA SAM写法 

val button = new JButton("Click") 
button.addActionListener(new ActionListener { 
  override def actionPerformed(event: ActionEvent){ 
    println("Click me") 
  } 
}) 

// 直接传入函数参数报错，类型不匹配 
scala> button.addActionListener{(event: ActionEvent) => println("click me")} 
<console>:15: error: type mismatch; 
 found   : java.awt.event.ActionEvent => Unit 
 required: java.awt.event.ActionListener 
              button.addActionListener{(event: ActionEvent) => println("click me")} 

// 隐式转换 

implicit def getActionListener(actionProcessFunc: (ActionEvent) => Unit) = new ActionListener{ 
  override def actionPerformed(event: ActionEvent){ 
    actionProcessFunc(event) 
  } 
} 

// 隐式转换后再传函数参数就ok了 
scala> button.addActionListener{(event: ActionEvent) => println("click me")} 

Currying函数

定义：将原来接收两个参数的一个函数，转换为两个函数。 
第一个函数接收原先的第一个参数，然后返回接收原先第二个参数的第二个函数。 
在函数调用的过程中，就变成了两个函数连续调用的形式。 
在Spark的源码中也使用了此特性。

scala> def sum(a: Int, b: Int) = a + b 
scala> sum(1,1) 
res30: Int = 2 

// Currying函数原理 
scala> def sum2(a: Int) = (b: Int) => a + b 
scala> sum2(1)(1) 
res31: Int = 2 

// Scala提供的更加简洁的语法 
scala> def sum3(a: Int)(b: Int) = a + b 
scala> sum3(1)(1) 
res32: Int = 2 

return

在Scala中，不需要使用return来返回函数值，但是如果要使用的话，该函数必须要给出返回类型，否则无法通过编译。

def functionName ([参数列表]) : [return type] = { 
   function body 
   return [expr] 
} 
 

object add{ 
   def addInt( a:Int, b:Int ) : Int = { 
      var sum:Int = 0 
      sum = a + b 
 
      return sum 
   } 
}