高阶函数

高阶函数：是一种特殊的函数，特殊之处在于：它指使用其他函数作为参数或者返回值。

什么是高阶函数？

Scala的常见高阶函数包括Array.map、flatten、flatmap、foreach、reduce、filter和fold等。

map函数

作用：通过对数组的每一个元素应用一个函数来构建一个新数组。（如：把数组(1,2,3,4,5) → (2,4,6,8,10)）

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

object Base52 {
  def main(args: Array[String]): Unit = {
    val arr = Array(1,2,3,4,5)
    var fn = (x:Int) => x * 2 // fn是一个字面量函数
    var arr1 = arr.map( fn ) // map是一个高阶函数，因为它的参数类型是函数
    // 用for循环输出
    for(i <- arr){
      println(i)
    }
  }
}

把数组中每个元素都变成之前的两倍，并把结果保留在新数组中

object Base52 {
  /**
   * 数组
   * 1.任务1：把数组中每个元素都变成之前的两倍，并把结果保留在新数组中
   *
   */
  def main(args: Array[String]): Unit = {
    val arr = Array(1,2,3,4,5)
    var fn = (x:Int) => x * 2 // fn是一个字面量函数
    var arr1 = arr.map( fn ) // map是一个高阶函数，因为它的参数类型是函数
    // 用for循环输出
    for(i <- arr1){
      println(i)
    }
  }
}

把(1,2,3,4,5)变成(1,4,9,16,25)

object Base52 {
  def main(args: Array[String]): Unit = {
    val arr = Array(1,2,3,4,5)
//    var fn = (x:Int) => x * 2 //fn是一个字面量函数
//    var arr1 = arr.map( fn ) //map是一个高阶函数，因为它的参数类型是函数
    //没有必要去单独定义一个函数fn，这里直接写在map函数内，此时，它就是一个匿名函数
    val arr1 = arr.map( x=> x*x) //前两个代码简写
    //用for循环输出
    for(i <- arr1){
      println(i)
    }
  }
}

把(-1,2,-3,-4)变成(1,2,3,4)

object Base52 {
  def main(args: Array[String]): Unit = {
    val arr = Array(-1,2,-3,-4)
//    var fn = (x:Int) => x * 2 //fn是一个字面量函数
//    var arr1 = arr.map( fn ) //map是一个高阶函数，因为它的参数类型是函数
    //没有必要去单独定义一个函数fn，这里直接写在map函数内，此时，它就是一个匿名函数
    val arr1 = arr.map( x=> if(x>0) x else -x) //前两个代码简写
    //用for循环输出
    for(i <- arr1){
      println(i)
    }
  }
}

匿名函数

object Base52 {
  def main(args: Array[String]): Unit = {
    val arr = Array(1,2,3,4,5)
//    var fn = (x:Int) => x * 2 //fn是一个字面量函数
//    var arr1 = arr.map( fn ) //map是一个高阶函数，因为它的参数类型是函数
//没有必要去单独定义一个函数fn，这里直接写在map函数内，此时，它就是一个匿名函数
    val arr1 = arr.map(x => x*2) //前两个代码简写
    //用for循环输出
    for(i <- arr1){
      println(i)
    }
  }
}

foreach函数

作用：对数组的每一个元素应用函数。

语法：数组.foreach(元素=>{})

object Base53 {
  /**
   * 数组
   * 1.把数组中的每个元素都打印出来
   * foreach:依次使用当前的函数来处理数组中的每一个元素
   */
  def main(args: Array[String]): Unit = {
    val arr = Array(-1,2,-3,-4,5)
  // arr.foreach(x=>{println(x)})
    arr.foreach(println)
  }
}

filter函数

作用：对数组元素使用函数进行过滤。

语法：新数组= 旧数组.filter(元素=>bool)  它的参数是一个函数，这函数的返回值是布尔值。如果返回为true就保留。

object Base54 {
  /**
   * 数组
   * 1.把数组中的偶数保留下来，组成新数组
   * filter:过滤
   * filter(函数fn)，如果fn的返回值是true，就保留这个元素
   */
  def main(args: Array[String]): Unit = {
    val arr = Array(1,2,3,4,5)
    val arr1 = arr.filter(x => x%2 ==0)
    arr1.foreach(println)
  }
}

去掉不及格的分数：(60,59,80,70) --> (60,80,70)

object Base54 {
  /**
   * 数组
   * 1.把数组中的偶数保留下来，组成新数组
   * filter:过滤
   * filter(函数fn)，如果fn的返回值是true，就保留这个元素
   */
  def main(args: Array[String]): Unit = {
    val arr = Array(60,59,80,70)
    val arr1 = arr.filter(x=> x>= 60)
    arr1.foreach(println)
  }
}

flatten函数

作用：将二维数组中的元素展平至单数组中。

语法：二维数组.flatten。不需要写（）

object Base55 {
  /**
   * 二维数组
   *flatten  不要加()的函数
   */
  def main(args: Array[String]): Unit = {
    var arr1 = Array(Array(1,2,3),  Array(4,5,6));
    //arr1(0).foreach(println)
    println(arr1(0)(0))
    var arr2 = arr1.flatten
    arr2.foreach(println)
  }
}