学习Scala_第八篇笔记

Scala函数高级

Scala匿名函数
1.说明
没有名字的函数就是匿名函数。
(x:Int)=>{函数体} x：表示输入参数类型；Int：表示输入参数类型；函数体：表示具体代码逻辑
2.传递匿名函数至简原则：
（1）参数的类型可以省略，会根据形参进行自动的推导
（2）类型省略之后，发现只有一个参数，则圆括号可以省略；其他情况：没有参数和参数超过 1 的永远不能省略圆括号。
（3）匿名函数如果只有一行，则大括号也可以省略
（4）如果参数只出现一次，则参数省略且后面参数可以用_代替

package exceeddata

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

    //定义一个函数，以函数作为参数输入
    def f(func: String => Unit): Unit = {
      func("智协慧同")
    }

    f(fun)
    f((name: String) => {
      println(name)
    })
    //匿名函数简化
    //参数类型可以省略，根据形参进行自动的推导
    f((name) => {
      println(name)
    })
    //类型省略之后，只有一个参数，圆括号可以省略
    f(name => {
      println(name)
    })
    //匿名函数若只有一行，大括号也可以省略
    f(name => println(name))
    //参数只出现一次，则参数省略且参数可以用_代替
    f(println(_))
    //若可以推断出，当前传入的println是一个函数体，而不是调用语句，可以直接省略下划线
    f(println)
  }
}

输出结果:
智协慧同
智协慧同
智协慧同
智协慧同
智协慧同
智协慧同
智协慧同

实际示例，定义一个"”二元运算”函数，只操(作1和2两个数，但是具体运算通过参数传入:

object test{
  def main(args: Array[String]): Unit = {
    def dualFunctionOneAndTwo(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(dualFunctionOneAndTwo(add))
    println(dualFunctionOneAndTwo(minus))
    //简化
    println(dualFunctionOneAndTwo((a,b) => a + b))
    println(dualFunctionOneAndTwo((a,b) => a - b))

    println(dualFunctionOneAndTwo(_+_))
    println(dualFunctionOneAndTwo(_ - _))

    println(dualFunctionOneAndTwo((a,b) => b - a))
    println(dualFunctionOneAndTwo(-_ + _))
  }
}

输出结果：
3
-1
3
-1
3
-1
1
1

object test{
  def main(args: Array[String]): Unit = {
    def f(n: Int): Int = {
      println("f调用")
      n + 1
    }

    def fun():Int = {
      println("f调用")
      1

    }
    val result: Int = f(123)
    println(result)
    fun()
    fun

    //1.函数作为值进行传递
    val f1: Int => Int = f
    val f2 = f _
    println(f1)
    println(f1(21))
    println(f2)
    println(f2(12))

    val f3 = fun
    val f4 = fun _
    val f5: ()=>Int = fun
    println(f3)
    println(f4)
    println(f5)
  }
}

练习 1：定义一个匿名函数，并将它作为值赋给变量 fun。函数有三个参数，类型分别为 Int，String，Char，返回值类型为 Boolean。要求调用函数 fun(0, “”, ‘0’)得到返回值为 false，其它情况均返回 true。

写法一：

def main(args: Array[String]): Unit = {
    val fun = (i1:Int,s1:String,c1:Char) => {
      if(i1 == 0 && s1 == "" && c1 == '0')false
      else true
    }
    var v1 = fun(0,"",'0')
    println(v1)
    println(fun(0,"",'0'))
  }

写法二：

def main(args: Array[String]): Unit = {
	val fun1 = (i1:Int, s1:String, c1: Char) => !(i1 == 0 && s1 == "" && c1 == '0')
    println(fun1(1,"",'0'))
    }

练习 2： 定义一个函数 func，它接收一个 Int 类型的参数，返回一个函数（记作 f1）。它返回的函数 f1，接收一个 String 类型的参数，同样返回一个函数（记作 f2）。函数 f2 接收一个 Char 类型的参数，返回一个 Boolean 的值。

def func(i:Int): String => Char =>Boolean={
     def f1(s:String): Char => Boolean = {
       def f2(c:Char):Boolean = {
         if(i == 0 && s =="" && c == '0') false else true
       }
       f2
     }
     f1
   }
   println(func(0)("")('0'))
   ```
   可以简化，func函数中可以不关心嵌套函数的名称，f1 f2可以用匿名函数表达：


def func(i:Int): String => Char =>Boolean={
//写到一行以后括号可以省略
     (s:String)=> (c:Char)=>if(i == 0 && s =="" && c == '0') false else true
   }
   println(func(0)("")('0'))
 
并且func中已经表明了类型，所以类型可以省略：

   def func(i:Int): String => Char =>Boolean={
     s=> c=>if(i == 0 && s =="" && c == '0') false else true
   }
   println(func(0)("")('0'))

参考一篇博文：

函数的高级用法：

1、函数可以作为值进行传递：

def fun1(a:Int):Int = {
    return a+1
}
 
val f1 = fun1(3)//得到的是函数的返回值
val f2 = fun1 _ //用“空格”+“_”的表示对函数本身的调用
println(f1)
printle(f2)

运行结果为：

4
function_learn.High_Order_Function$$$Lambda$1/1023892928@31b7dea0

f2的返回值是一个地址。

如果能知道函数的参数类型和返回值类型，可以不用_也能进行函数的传递：

val f1:Int => Int = add

2、函数可以作为函数的参数进行传递：

  def main(args: Array[String]): Unit = {
    def add(a:Int,b:Int):Int= a+b
    def v1(func:(Int,Int) => Int,a:Int,b:Int): Int ={
      func(a,b)
    }
    println(v1(add,12,15))
  }

也可以传递匿名函数。
3、函数可以作为函数的返回值返回：

def v2(): Int=>Unit = {
  def v3(a:Int): Unit = println("i am v3")
  v3
}
println(v2())
}

运行结果为：

Package01.Test02$$$Lambda$3/97730845@50675690

这是因为v2返回的是一个函数v3，如要调用v3函数，可以新建一个变量接受v2的返回值：

  val v4 = v2()
  println(v4(1))

返回值是：

i am v3
()

Scala中还可以直接调用：

println(v2()(1))

与上述代码效果相同。

Scala高阶函数的例子：

object test {
  def main(args: Array[String]): Unit = {
     val array: Array[Int] =Array(4,3,5,6)
     def arrayOperation(array: Array[Int], op: Int=>Int): Array[Int] = {
       for (elem <- array) yield op(elem)
    }
    def add(elem: Int): Int = {
      elem + 1
    }
    //调用函数
   val newArray: Array[Int] = arrayOperation(array,add)
   println(newArray.mkString(","))

    //传入匿名函数，实现元素翻倍
    val newArray2 = arrayOperation(array,elem => elem * 2)
    println(newArray2.mkString(","))
    val newArray3 = arrayOperation(array,_* 2)
    println(newArray3.mkString(","))
  }
}