而在大量的spark中大都用的是匿名函数(不为函数命名)，然后将其复制个一个变量。
如：
匿名函数格式：
Val 变量名 = （参数：类型） => 函数体
如：
这个函数也是一样，只要理解了返回值是类型一个匿名函数就行了。
def addBy(factor:Int) = {
(x:Double)=> factor + x
}
(x:Double) 是返回函数的参数定义，返回类型由表达式 factor +x 来决定。如果表达式比较复杂，也可以如下写法
(x:Double)=> { do some things }
我们看看如何调用函数
package com.dt.scala.hello
import scala.math._
object ScalaInAction {
def addBy(factor:Int) = {
(x:Double)=> factor + x
} //> addBy: (factor: Int)Double => Double
val addFive = addBy(5) //> addFive : Double => Double = <function1>
println(addFive(20))
柯里化指的是将原来接受两个参数的方法变成新的接受一个参数的方法的过程
object CurringFuncTest { def main(args: Array[String]): Unit = { //正常定义1 def multiple1(x:Int,y:Int) = x*y println(multiple1(2,3)) //其中一个函数作为返回值 def multiple2(x:Int)=(y:Int)=>x*y println(multiple2(3)(4)) //柯里化 def multiple3AfterCurring(x:Int)(y:Int) = x*y println(multiple3AfterCurring(4)(5)) //必须传递两个参数，否则编译报错 val a = Array("XX","YY") val b = Array("xx","yy") println(a.corresponds(b)(_.equalsIgnoreCase(_))) } }
6
12
20
true
当Scala编译器进行类型匹配时，如果找不到合适的候选，那么隐式转化提供了另外一种途径来告诉编译器如何将当前的类型转换成预期类型。
1.将方法或变量标记为implicit
2.将方法的参数列表标记为implicit
3.将类标记为implicit
隐式值：用于给方法提供参数
隐式视图：用于类型间转换或使针对某类型的方法能调用成功
例1：声明person方法。其参数为name，类型String
scala> def person(implicit name : String) = name //name为隐式参数
person: (implicit name: String)String
直接调用person方法
scala> person
<console>:9: error: could not find implicit value for parameter name: Stringperson
报错！编译器说无法为参数name找到一个隐式值
定义一个隐式值后再调用person方法
scala> implicit val p = "mobin" //p被称为隐式值
p: String = mobin
scala> person
res1: String = mobin
因为将p变量标记为implicit，所以编译器会在方法省略隐式参数的情况下去搜索作用域内的隐式值作为缺少参数。
但是如果此时你又在REPL中定义一个隐式变量，再次调用方法时就会报错
scala> implicit val p1 = "mobin1"
p1: String = mobin1
scala> person
<console>:11: error: ambiguous implicit values:
both value p of type => String
and value p1 of type => String
match expected type String person
匹配失败，所以隐式转换必须满足无歧义规则，在声明隐式参数的类型是最好使用特别的或自定义的数据类型，不要使用Int,String这些常用类型，避免碰巧匹配
在scala2.10后提供了隐式类，可以使用implicit声明类，但是需要注意以下几点：
1.其所带的构造参数有且只能有一个
2.隐式类必须被定义在类，伴生对象和包对象里
3.隐式类不能是case class（case class在定义会自动生成伴生对象与2矛盾）
4.作用域内不能有与之相同名称的标示符
object Stringutils { implicit class StringImprovement(val s : String){ //隐式类 def increment = s.map(x => (x +1).toChar) } } object Main extends App{ import com.mobin.scala.implicitPackage.Stringutils._ println("mobin".increment) }
编译器在mobin对象调用increment时发现对象上并没有increment方法，此时编译器就会在作用域范围内搜索隐式 实体，发现有符合的隐式类可以用来转换成带有increment方法的StringImprovement类，最终调用increment方法。
1.当方法中的参数的类型与目标类型不一致时
2.当对象调用类中不存在的方法或成员时，编译器会自动将对象进行隐式转换
即编译器是如何查找到缺失信息的，解析具有以下两种规则：
1.首先会在当前代码作用域下查找隐式实体（隐式方法 隐式类 隐式对象）
2.如果第一条规则查找隐式实体失败，会继续在隐式参数的类型的作用域里查找
类型的作用域是指与该类型相关联的全部伴生模块，一个隐式实体的类型T它的查找范围如下：
（1）如果T被定义为T with A with B with C,那么A,B,C都是T的部分，在T的隐式解析过程中，它们的伴生对象都会被搜索
（2）如果T是参数化类型，那么类型参数和与类型参数相关联的部分都算作T的部分，比如List[String]的隐式搜索会搜索List的
伴生对象和String的伴生对象
（3） 如果T是一个单例类型p.T，即T是属于某个p对象内，那么这个p对象也会被搜索
（4） 如果T是个类型注入S#T，那么S和T都会被搜索
1.不存在二义性
2.隐式操作不能嵌套使用（如 convert1(covert2(x))）+y
3.代码能够在不使用隐式转换的前提下能编译通过，就不会进行隐式黑铁