Scala函数进阶

定义函数的方式

1. 定义函数方式一：def

def getSum(x:Int , y:Int) : Int = {
  x+y
}

def main(args: Array[String]): Unit = {
  println(getSum(10,20))
  println(getSum1(10,20))
}

2.定义函数的方式二：字面量

  val getSum1 = (x:Int , y:Int) => {
    x+y
  }
  
def main(args: Array[String]): Unit = {
  println(getSum(10,20))
  println(getSum1(10,20))
}

函数的字面量语法

语法：var 变量 = (参数列表)=>{方法体}

它省略了def，函数名以及函数的返回值类型。

// 定义  
val sum1 = (x:Int, y:Int)=>{x+y}  
// 调用  
var s = sum1(10,34)

[简化写法]

第一种方式为：_（占位符）。如果函数中的参数在方法体中只使用了一次，可以用_替换。

第二种方式为：只有一个表达式时，可以省略{ }。

//函数字面量的简化手法
//1.代码只有一句 省略 {}
//2.使用_占位符来代替形参
//
  val getSum = (x:Int , y:Int) => {
    x+y
  }
  //省略 {}
  val getSum1 = (x:Int , y:Int) => x+y

  //使用_占位符来代替形参
  val getSum2 = (_:Int) + (_:Int)

  //使用_占位符来代替形参
  val getSum3 :(Int , Int) =>Int= _ + _

    def main(args: Array[String]): Unit = {
    println(getSum(10,20))
    println(getSum1(10,20))
    println(getSum2(10,20))
    println(getSum3(10,20))

  }

把函数作为参数

定义一个接收函数作为参数的函数def a(f:()=>Unit)={}，其中函数的类型()=>Unit部分()为函数的参数， Unit为函数的返回值。通过定义字面量传递值时，字面量必须和函数的类型匹配。

//  把一个函数 当做参数 传递给另一个函数
//
//  定义两个字面量函数
 val f1:(Int ,Int) => Int =_ + _
 // val a:Int

 val f2:(Int ,Int) => Int =_ + _

//  定义一个函数 他有三个参数
//  参数1：类型是(Int,Int) =>Int 他表示这里需要一个函数
   def test (fn:(Int,Int) => Int,x:Int,y:Int) = {
     fn(x,y)
   }

   def main(args: Array[String]): Unit = {
   println(test(f1,10,20))
   println(test(f2,10,20))
 }

scala部分应用函数

如果一个函数包含多个参数，对该函数传递部分参数使得这个函数返回一个函数，那么这种函数叫做部分应用函数。

// 定义普通函数  
def mutlti(x:Int, y:Int, z:Int) = {  
  println(s"$x, $y, $z")  
  x * y * z  
}  
// 传入部分参数，返回部分函数  
var f1 = mutlti(2, _, _)  
// 调用部分函数  
println( f1(10, 5) )

例如：

val getSum = (a:Int , b:Int,c:Int) => {
  a + b + c
}

def main(args: Array[String]): Unit = {
  println(getSum(10,20,30))

  val t = getSum(10,20,_) //t就是部分应用函数

  val t1 = getSum(_,20,_)

  println(t(50))
  println(t1(20,50))
}