Scala函数

Scala 函数

1. 函数定义语法

2. 递归函数

   阶乘

   package com.ronnie.scala.function
   
   object RecursiveDemo {
     /**
       *  阶乘
       * @param num
       * @return
       */
     def factorial(num :Int):Int = {
       if (0 == num){
         0
       }else if (1 == num){
         1
       } else {
         num * factorial(num - 1)
       }
   
     }
   
     /**
       *  斐波那契数列求和
       * @param num
       * @return
       */
     def fibonacciSum(num :Int):Int = {
       if (0 == num){
         0
       } else if (1 == num){
         1
       } else if (2 == num) {
         1
       } else {
         num + fibonacciSum(num - 1)
       }
     }
   
     def main(args: Array[String]): Unit = {
       println(factorial(3))
       println(fibonacciSum(3))
     }
   }
   

3. 包含参数默认值的函数

   • 默认值的函数中，如果传入的参数个数与函数定义相同，则传入的数值会覆盖默认值

   • 如果不想覆盖默认值，传入的参数个数小于定义的函数的参数，则需要指定参数名称。

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

4. 可变参数个数的函数scala

   • 函数声明中 参数类型后加* 类比java中...
   • 多个参数用逗号分开

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

5. 匿名函数

   • 有参匿名函数
   • 无参匿名函数
   • 有返回值的匿名参数

     • 可以将匿名函数返回给 val 定义的值

     • 匿名函数不能显式声明函数的返回类型

       /**
           * 匿名函数
           * 1.有参数匿名函数
           * 2.无参数匿名函数
           * 3.有返回值的匿名函数
           * 注意：
           * 可以将匿名函数返回给定义的一个变量
           */
         // 有参匿名函数
         val v1 = (a : Int) => {
           println(a)
         }
         v1(1)
         // 无参数匿名函数
         val v2 = () =>{
           println("This is just a simple test.")
         }
         v2()
         // 有返回值的匿名函数
         val v3 = (a:Int, b:Int) =>{
           a - b
         }
         println(v3(7,4))
       }
       

6. 嵌套函数

     def fun5(num: Int)={
       def fun6(a:Int, b:Int):Int={
         if (a % 16384 == 1){
           b
         } else {
           fun6(a - 1, a % b)
         }
       }
       fun6(num, 3)
     }
     println(fun5(39327))
   }
   

7. 偏应用函数

   • 是一种表达式, 不需要提供函数需要的所有参数, 只需要提供部分, 或不提供所需函数

       /**
         *  偏应用函数
         */
       def log(date : Date, s : String) = {
         println("date is " + date + ",log is " + s)
       }
       val date = new Date()
       log(date, "log01")
       log(date, "log02")
       log(date, "log03")
       
       // 要调用log, 以上变化的是第二个参数, 可以用偏应用函数处理
       val logWithDate = log(date,_:String)
       logWithDate("log011")
       logWithDate("log022")
       logWithDate("log033")
     

8. 高阶函数

   • 函数的参数是函数, 或者函数的返回类型是函数, 或者函数的参数和函数的返回类型是函数的函数。

     • 函数的参数是函数
     • 函数的返回时函数
     • 函数的参数和函数的返回是函数

     package com.ronnie.scala.function
     
     object HighOrderFunction {
        def f(x1 :Int, x2: Int, y1: Int, y2: Int): Int = {
          if (x1 == x2){
            -10086
          }
          (y1 - y2) / (x1 - x2)
        }
     
        // 函数的参数是函数
        def hof01(f: (Int,Int,Int,Int) => Int, a:Int = -1) :Int = {
          f(3, 1, 4, 7) + a
        }
     
        // 函数的返回时函数
        def hof02(a : Int, b : Int) : (Int, Int) => Int = {
          def f2 (c : Int, d : Int): Int = {
            if (d == c){
              -10086
            } else {
              (b - a) / (d - c)
            }
          }
          f2
        }
     
       // 函数的参数是函数, 函数的返回时函数
       def hof03(f: (Int, Int, Int, Int) => Int) : (Int, Int, Int, Int) => Int = {
         f
       }
     
       def main(args: Array[String]): Unit = {
         println(hof01(f))
         println(hof02(-4, 3)(7, 7))
         println(hof02(-4, 3)(7, 1))
     
         println(hof03((a, b, c, d) => {(b - a)/(d - c)})(-4, 3, 7, 1))
         // 括号中带括号不支持 println(hof03((_-_)/(_-_))(-4, 3, 7, 1))
         println(curring(-4, 3)(8, 8))
         println(curring(-4, 3)(8, 1))
       }
     

9. 柯里化函数

   • 可以理解为高阶函数的简化

   // 函数柯里化
     def curring(a : Int, b : Int)(c : Int, d : Int) = {
       if (c == d){
         -10086
       } else {
         (b - a)/(d - c)
       }
     }