scala 方法与函数（2.11）

Scala 介绍

Spark1.6 中使用的是 Scala2.10。Spark2.0 版本以上使用是 Scala2.11 版本。

Scala 官网 6 个特征

1. Java 和 scala 可以混编
2. 类型推测 (自动推测类型)
3. 并发和分布式（Actor）
4. 特质，特征 (类似 java 中 interfaces 和 abstract 结合)
5. 模式匹配（类似 java switch）
6. 高阶函数

scala 方法与函数

递归方法

5 4 3 2 1

def fun2(num :Int) :Int= {if(num ==1)
        num
      else 
        num * fun2(num-1)
    }
    print(fun2(5))

参数默认值方法

  /**
     * 包含默认参数值的函数
     * 注意：* 1. 默认值的函数中，如果传入的参数个数与函数定义相同，则传入的数值会覆盖默认值
     * 2. 如果不想覆盖默认值，传入的参数个数小于定义的函数的参数，则需要指定参数名称
     */
    def fun3(a :Int = 10,b:Int) = {println(a+b)
    }
    fun3(b=2)
    fun3(12,2)

可变参数方法

   /**
     * 可变参数个数的函数
     * 注意：多个参数逗号分开
     */
    def fun4(elements :Int*)={
      var sum = 0;
      for(elem <- elements){sum += elem}
      sum
    }
    println(fun4(1,2,3,4))

匿名函数

 /**
     * 匿名函数
     * 1. 有参数匿名函数
     * 2. 无参数匿名函数
     * 3. 有返回值的匿名函数
     * 注意：* 可以将匿名函数返回给定义的一个变量
     */
    // 有参数匿名函数
    val value1 = (a : Int) => {println(a)
    }
    value1(1)
    // 无参数匿名函数
    val value2 = ()=>{println("我爱中国")
    }
    value2()
    // 有返回值的匿名函数
    val value3 = (a:Int,b:Int) =>{a+b}
    println(value3(4,4)) 

嵌套方法

/**
     * 嵌套方法
     * 例如：嵌套方法求 5 的阶乘
     */
    def fun5(num:Int)={def fun6(a:Int,b:Int):Int={if(a == 1){b}else{fun6(a-1,a*b)
        }
      }
      fun6(num,1)
    }
    println(fun5(5))

偏应用函数

偏应用函数是一种表达式，不需要提供函数需要的所有参数，只需要提供部分，或不提供所需参数。

 /**
     * 偏应用函数
     */
    def log(date :Date, s :String)= {println("date is"+ date +",log is"+ s)
    }
    
    val date = new Date()
    log(date ,"log1")
    log(date ,"log2")
    log(date ,"log3")
    
    // 想要调用 log，以上变化的是第二个参数，可以用偏应用函数处理
    val logWithDate = log(date,_:String)
    logWithDate("log11")
    logWithDate("log22")
    logWithDate("log33")

高阶函数

1. 函数的参数是函数
2. 函数的返回是函数
3. 函数的参数和函数的返回是函数

// 函数的参数是函数
    def hightFun(f : (Int,Int) =>Int, a:Int ) : Int = {val i = f(50,100)
      i + a
    }
    
    println(hightFun((x:Int,y:Int)=> {x+y}, 1))
    println(hightFun((x:Int,y:Int)=> {x*y}, 1))
    
    // 函数的返回是函数
    //1，2,3,4 相加
    def hightFun2(a : Int,b:Int) : (Int,Int)=>Int = {def f2 (v1: Int,v2:Int) :Int = {v1+v2+a+b}
      f2
    }
    println(hightFun2(1,2)(3,4))
    
    // 函数的参数是函数，函数的返回是函数
    def hightFun3(f : (Int ,Int) => Int) : (Int,Int) => Int = {f} 
    println(hightFun3((a,b) =>{a+b})(200,200))
    // 以上这句话还可以写成这样
    // 如果函数的参数在方法体中只使用了一次 那么可以写成_表示
    println(hightFun3(_+_)(200,200))

柯里化函数

高阶函数的简化

/**
     * 柯里化函数
     */
    def fun7(a :Int,b:Int)(c:Int,d:Int) = {a+b+c+d}
    println(fun7(1,2)(3,4))