scala學習--方法與函數

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))