写在前面
众所周知，scala一向宣称自己是面向函数的编程，（java表示不服，我是面向bean的编程！）那什么是函数？
在接触java的时候，有时候用函数来称呼某个method（实在找不出词了），有时候用方法来称呼某个method，虽然method的中文翻译就是“方法”，但对于java来说，方法和函数是等价的，或者说没有函数这个概念。
而对于scala，这两者似乎有一个较为明确的边界。
你会发现满世界的函数，而你却在写方法
Scala 方法&函数
方法
Scala的方法和java可以看成是一样的，只是多了点语法糖。
比如无参方法在申明时可以不加括号，甚至在调用过程也不用加括号
def f = 1+1 println(f)
比如方法可以添加泛型规则，这在java中只能在类申明
def f[T](t: T) = {t}
还有其它很多细节语法，遇到才深入吧
一般而言只要知道函数的结构就行（但是我想说，spark的代码就没有一个函数长成这样的啊..），请忽略下图的“函数”字样，其实就是方法
方法应用
def method(): Unit ={
//本地方法
def print(str:String): Unit ={
println(str)
}
print("hello")
}
方法的语法还是跟java差不多的，只是有些可以省略而已。
比较重要的就是本地方法，即方法中嵌套方法
函数
Scala的函数是基于Function家族，0-22，一共23个Function Trait可以被使用，数字代表了Funtcion的入参个数
函数语法
下面这四个函数的意义是一样的
// println(fun1)
// println(fun2)
// println(fun3)
// println(fun4)
// 都为<function2>
val fun1 = new Function2[Int,Int,Int]() {
override def apply(v1: Int, v2: Int): Int = {
v1+v2
}
}
val fun2 = new ((Int, Int) => Int)() {
override def apply(v1: Int, v2: Int): Int = {
v1+v2
}
}
val fun3 = (v1:Int,v2:Int) => v1+v2
// _可以把method转换成function
val fun4 = fun4Method _
def fun4Method(v1:Int,v2:Int): Int = {
v1+v2
}
一般我们都采用第三种fun3定义方式，也是最难懂的一个定义方式。具体结构参考下图
那函数有什么用呢?
Java里只有方法都能适应一切需求，那scala又提出函数的概念肯定有意义。
1.函数可以直接赋值给变量，可以让函数很方便的传递
2.闭包（closure），可以把灵活操作代码块，从而引申出其他灵活的语法
函数应用
在spark中，有很多方法入参中使用函数的场景，比如如下函数
defrunJob[T,U](fun: Iterator[T] => U ,resHandler: (Int, U) => Unit): Unit ={
//忽略里面的逻辑
}
其中的fun和resHandler都是函数
Fun是入参为Iterator[T],返回值为U的函数，一个入参的函数其实就是Function1的实例
resHandler是入参为Int和 U无返回值的函数，二个入参的函数其实就是Function2
模拟spark中常见的一段代码语法，拿一个普通scala类型的例子来说
//模拟spark的runJob方法
def runJob[T,U](fun: Iterator[T] => U ,resHandler: (Int, U) => Unit): Unit ={
val listBuffer = new ListBuffer[T]
listBuffer.append("h".asInstanceOf[T])
listBuffer.append("e".asInstanceOf[T])
listBuffer.append("l".asInstanceOf[T])
listBuffer.append("l".asInstanceOf[T])
listBuffer.append("o".asInstanceOf[T])
//这里调用函数其实用到了伴生对象的概念，fun(xxx)就是fun.apply(xxx)
val res = fun(listBuffer.iterator)
//spark中，这里是每个partition的数据都存入arr，这里做模拟就一个partition了:)
resHandler(0,res)
}
//模拟调用runJob的方法
def main(args: Array[String]): Unit = {
val arr = new Array[String](1)
//fun函数的实际逻辑
val fun = (it:Iterator[String]) => {
val sb = new StringBuilder()
while (it.hasNext)
sb.append(it.next())
sb.toString()
}
//resHandler函数的实际逻辑
val resHandler = (i:Int,res:String) => arr(i) = res
runJob[String,String](fun ,resHandler)
println(arr.mkString(""))
}
其实就是传递函数的逻辑，和java的匿名类差不多（只有一个方法的匿名类），只是多了点语法糖
这么做的好处也是不言而喻的
1.可以构造出更抽象的方法，使得代码结构更简洁
2.spark的思想就是lazy，而函数传递也是一个lazy的过程，只有在实际触发才会执行
偏函数
英文为PartialFunction，不知道这么翻译对不对，貌似都这么叫。
PartialFunction其实是Funtion1的子类
参考源码
trait PartialFunction[-A, +B] extends (A => B)
A => B就是标准的函数结构
那PartialFunction有什么作用呢？
模式匹配！
PartialFunction最重要的两个方法，一个是实际的操作逻辑，一个是校验，其实就是用来做模式匹配的。
参考资料
《Scala编程》