Scala函数及其高阶应用

函数基本概念

object test01 {
  def main(args: Array[String]): Unit =
  {
    //return 可以省略，函数体最后一行代码为返回值
    def f0(name:String):String={
      name
    }
    println(f0("zhong"))
    println("--------------------------")

    //一行代码，可省略花括号
    def f1(name:String):String=name
    println(f0("zhong"))
    println("--------------------------")

    //返回值类型可以推断出来，则可以省略
    def f2(name:String)=name   //f(x)=x
    println(f0("zhong"))
    println("--------------------------")

    //有return则必须写返回值
    //返回声明为unit，return则不起作用，可不写

    //无返回值类型，可省略等号
    def f3(name:String): Unit ={
      println(name)
    }
    f3("zhong")
    println("--------------------------")
    //函数无参，但声明了参数列表，调用时小括号可加可不加
    def f4():Unit={
      println("zhong")
    }
    f4()
    f4
    println("--------------------------")
                  
    //函数没有参数列表，小括号可以省略，调用时小括号必须省
    def f5:Unit={
      println("zhong")
    }
    f5
    println("--------------------------")
    //如果不关心名称，只关心逻辑处理，那么def也可省略
    (name:String)=>{println(name)}  //lambda表达式
  }
}

匿名函数

object test01 {
  def main(args: Array[String]): Unit = {
    val fun=(name:String)=>{println(name)}
    fun("zhong")

    //以函数作为函数输入
    def f(func:String=>Unit):Unit={
      func("zhong")
    }
    f(fun)
    f((name:String)=>{println(name)})
    //可省略大会括号
    f((name:String)=>println(name))
    //可省略返回值
    f((name)=>println(name))
    //一个参数，可省略括号
    f(name=>println(name))
    //参数只出现一次，可用_代替
    f(println(_))
    //若传入是一个函数体，非调用语句，可省略_
    f(println)
  }
}

固定数值，传入函数

object test01 {
  def main(args: Array[String]): Unit = {
    //定义一个二元运算，只操作1和2两个数，集体运算通过参数传入
     def f(fun:(Int,Int)=>Int):Int={
       fun(1,2)
     }
    val add=(a:Int,b:Int)=>a+b
    val minus=(a:Int,b:Int)=>a-b
    println(f(add))
    println(f(minus))
    println("----------------------")
    println(f((a:Int,b:Int)=>a+b))
    println(f((a:Int,b:Int)=>a-b))
    println("----------------------")
    println(f((a,b)=>a+b))
    println(f((a,b)=>a-b))
    println("----------------------")
    println(f(_+_))
    println(f(_-_))
    println(f((a,b)=>b-a))
    println(f(-_+_))
  }
}

函数作为值进行传递

object test01 {
  def main(args: Array[String]): Unit = {
   def f(n:Int):Int={
     println("f调用")
     n+1
   }
    val result=f(123)
    println(result)
    //函数作为值进行传递
    val f1:Int=>Int=f
    val f2=f _
    println(f1)
    println(f1(24))
    println(f2)
    println(f2(24))
  }
}

函数作为参数进行传递，函数可作为函数的返回值返回

object test01 {
  def main(args: Array[String]): Unit = {
   //函数作为参数进行传递，定义二元运算函数
    def f(op:(Int,Int)=>Int,a:Int,b:Int):Int={
      op(a,b)
    }
    val a=f((a,b)=>a+b,12,35)
    println(a)
    //函数可作为函数的返回值返回
    def f1():Int=>Unit={
      def f2(a:Int):Unit={
        println("f2调用 "+a)
      }
      f2
    }
    val f3=f1()
    println(f3(33))
    println(f1()(25))
  }
}

应用案例：相当于map操作

object test01 {
  def main(args: Array[String]): Unit = {
    val arr:Array[Int]=Array(12,34,65,88)
    //对数组进行处理，将操作抽象出来，处理完毕后返回一个新的数组
    def arrayOps(array: Array[Int],op:Int=>Int):Array[Int]={
      for(elem<-array) yield op(elem)
    }
    //定义一个加1操作，调用
    val arr1=arrayOps(arr,a=>a+1)
    println(arr1.mkString(","))

    //定义一个乘2操作
    val arr2=arrayOps(arr,a=>a*2)
    println(arr2.mkString("|"))
  }
}