函数进阶

一、函数字面量（另一种定义函数的方式）

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

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

2.定义：val sum1 = (x:Int, y:Int)=>{x+y}

//定义函数的方式一：def
def getSum(x:Int, y:Int ):Int = {
  x + y
}

// 定义函数的方式二：字面量
val getSum1 = (x:Int, y:Int) => {
  x + y
}

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

3.Scala的函数字面量的简化方式有两种方式:

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

（2）第二种方式为：只有一个表达式时，可以省略括号。

 // 函数字面量的简化写法
// 1.代码只有一句话，省略{ }
//2._占位符来替换形参

  //定义函数的方式一：def
  def getSum(x:Int, y:Int ):Int = {
    x + y
  }

  // 定义函数的方式二：
  
  // 省略{ }
  val getSum1 = (x:Int, y:Int) => x + y
  
  // 使用 _ 来替换形参
  val getSum2 = (_:Int) + (_:Int)
  
  //使用 _ 来替换形参。(Int, Int) => Int 就是getSum3的类型
  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))
  }

二、把函数作为参数

题目：

// 把一个函数当做参数，传递给另外一个函数

// 定义两个字面量函数。(Int, Int) => Int看成一种数据类型
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):Int = {
  fn(x,y)
}

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

三、部分应用函数

题目：

// 部分应用函数
// 如果一个函数需要3个参数，而我们只给了2个参数，会怎么样？

def getSum(a:Int, b:Int, c:Int):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,_) // t1就是部分应用函数


  println(t(50))

  println(t1(20,50))
}

四、高阶函数

1.定义：一种特殊的函数，它的参数或者返回值是函数类型

2.作用：通过对数组的每一个元素的应用一个函数来构建一个新数组

3.语法：新数组 = 旧数组.map(旧元素=>新元素

例：

def main(args: Array[String]): Unit = {
  val arr1 = Array(1,2,3,4,5,6)
  // Array是一个构造器，用来定义一个数组
  // arr1 就是一个数组对象，它有很多的方法，其中就有map
  // for 循环来输出数组中每个元素


  val fn = (x:Int) => x * 2
  // fn是一个函数，它被传给了map, map是一个高阶函数
  val arr2 = arr1.map(fn)


  // for 循环来输出数组中每个元素
  for(i <- arr2){
    println(i)
  }
}