Scala函数

yunfenglee 2019-10-19

Scala 函数

  1. 函数定义语法

Scala函数

  1. 递归函数

    阶乘

    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))
      }
    }
  2. 包含参数默认值的函数

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

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

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

    • 函数声明中 参数类型后加* 类比java中...
    • 多个参数用逗号分开
    /**
        * 可变参数个数的函数
        * 注意:多个参数逗号分开
        */
      def fun4(elements : Int*)={
        var sum = 0;
        for (elem <- elements){
          sum += elem
        }
        sum
      }
      println(fun4(1,2,3,4,5,6))
  4. 匿名函数

    • 有参匿名函数
    • 无参匿名函数
    • 有返回值的匿名参数
      • 可以将匿名函数返回给 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))
        }
  5. 嵌套函数

    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))
    }
  6. 偏应用函数

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

      /**
          *  偏应用函数
          */
        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")
  7. 高阶函数

    • 函数的参数是函数, 或者函数的返回类型是函数, 或者函数的参数和函数的返回类型是函数的函数。
      • 函数的参数是函数
      • 函数的返回时函数
      • 函数的参数和函数的返回是函数
      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))
        }
  8. 柯里化函数

    • 可以理解为高阶函数的简化
    // 函数柯里化
      def curring(a : Int, b : Int)(c : Int, d : Int) = {
        if (c == d){
          -10086
        } else {
          (b - a)/(d - c)
        }
      }

相关推荐

kekeromer / 0评论 2020-04-30