16.高阶函数

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

话不多说，代码如下：

object Base61 {
  def main(args: Array[String]): Unit = {

    val arr = Array(1,2,3,4,5)

    val fn = (x:Int) => x * 2  //fn是一个字面量函数

    val arr1 = arr.map( fn ) // map是一个高阶函数，因为它的参数类型是 函数！
    
    //用for循环输出
    for(i <- arr1){
      println(i)
    }
  }
}

关于上面代码，没有必要单独定义一个函数fn，这里直接写在map函数内，此时，它就是一个匿名函数

更改后代码如下：

object Base61 {
  def main(args: Array[String]): Unit = {

    val arr = Array(1,2,3,4,5)

    val arr1 = arr.map( x=> x * 2 )

    for(i <- arr1){
      println(i)
    }
  }
}

运行结果： 2 4 6 8 10

练习：把(1,2,3,4,5) ->(1,4,9,16,25)

object Base62 {
  def main(args: Array[String]): Unit = {

    val arr = Array(1,2,3,4,5)

    val arr1 = arr.map( x=> x * x )

    for(i <- arr1){
      println(i)
    }
  }
}

那结果毋庸置疑：1 4 9 16 25

练习：把(-1,2,-3,-4) -> (1,2,3,4)

object Base62 {
  def main(args: Array[String]): Unit = {

    val arr = Array(-1,2,-3,-4)

    val arr1 = arr.map( x=> if(x>0)x else -x )

    for(i <- arr1){
      println(i)
    }
  }
}

结果依旧正确：1 2 3 4

把数组中每个元素都打印出来

foreach:依次使用当前的函数来处理数组中的每一个元素

object Base63 {
  def main(args: Array[String]): Unit = {
    val arr = Array(-1,2,-3,-4,5)
    arr.foreach(println)
  }
}

结果：

-1
2
-3
-4
5

把数组中的偶数保留下来，组成新数组

    filter：过滤
    filter（函数fn），如果fn的返回值是true，就保留这个元素

object Base64 {
  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 Base65 {
  def main(args: Array[String]): Unit = {
    val arr = Array(60,59,80,70)
    val arr1 = arr.filter(x => x>=60)
    arr1.foreach(println)
  }
}

结果依旧： 60 80 70

将(1,2,3)(4,5,6)->(1,2,3,4,5,6)

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

object Base66 {
  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)
  }
}

reduce:聚合。

object Base67 {
  def main(args: Array[String]): Unit = {
    var arr = Array(1,2,3,4,5)

    var sum = arr.reduce((x,y)=> x+y)
    // var s = arr.sum
    println(sum)
  }
}

结果：15

求最大值和最小值

object Base68 {
  def main(args: Array[String]): Unit = {
    var arr = Array(-1,20,30,14)

    val max = arr.reduce((x,y) => if (x>y) x else y)

    println(max)

    val min = arr.reduce((x,y) => if (x<y) x else y)


    println(min)
  }
}

结果：30 -1

fold：带初值的reduce

object Base69 {
  def main(args: Array[String]): Unit = {
    var arr = Array(1,2,3)

//    val sum = arr.reduce((x,y) => x+y)
    val sum1 = arr.fold(100)((x,y)=>x+y)

    println(sum1)
  }
}

结果：106

sorted:对元素进行排序。它会直接使用自身的自然顺序进行排序。

object Base70 {
  def main(args: Array[String]): Unit = {
    var arr = Array(-1,20,3,2,50)

    var arr1 = arr.sorted
    var arr2 = Array("banana","zip","b","a","apple")
    var arr3 = arr2.sorted
    arr1.foreach(println)
    arr3.foreach(println)
  }

sortedWith:

如何将Array(-1,0,1,3,2)中的所有元素，按它们到0点的距离排序？

object Base71 {
  def main(args: Array[String]): Unit = {
    var arr = Array(-1,0,1,3,2)
//    排序函数：（元素a，元素b）=>Bool。乳沟返回true，则 表示 元素a 应排在 元素b 之前
//    var arr1 = arr.sortWith((a,b)=> a到0的距离 < b到0的距离)
    对arr中所有元素按照他们距离 3 的距离的大小从小到大排序
    var arr1 = arr.sortWith( (a,b)=> Math.abs(a-3) < Math.abs(b-3))
    arr1.foreach(println)
  }
}