高阶函数

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

object w10 {
  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是一个高阶函数，因为它的函数参数类型是函数

    //没有必要单独去定义一个函数fn，这里直接写在map函数内，此时，它就是一个匿名函数
    val arr1 =arr.map(x => x*2)
    //for循环输出
    for(i <- arr1) {
      println(i)
    }
  }
}

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

object w11 {
  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,2,-3,-4)->(1,2,3,4)

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

}

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

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

}

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

object w14 {
  /**
   * 1. 把数组中的偶数保留下来，组成新数组
   * filter：过滤
   * filter(函数f)，如果f的返回值是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)
  }
}

（1,2，3）（4,5,6）->(1,2,3,4,5,6)

object w16 {
  /**
   * 二维数组
   * 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))
    val arr2 = arr1.flatten
    arr2.foreach(println)
  }
}

reduce:聚合

object w17 {
//reduce:聚合
def main(args: Array[String]): Unit = {
  var arr =Array(1,2,3,4,5)
  var sum =arr.reduce((x,y)=>x+y)
  println(sum)
}
}

求数组最大最小值

object w18 {
//reduce:聚合
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) y else x)
  println(min)
}
}

fold()求和

object w19 {
  /**
   * fold：带初始值的reduce
   */
  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) // 106
    println(sum1) //
  }
}

object w20 {
  def main(args: Array[String]): Unit = {
    var arr = Array(-1, 12, 0, 5, 3)
    // 排序
    // var arr1 = arr.sorted  // 对于数值类型的数组，从小到大升序排列

    var arr2 = Array("banana", "zip", "b", "a", "apple")
    // 排序
     var arr3 = arr2.sorted  // 对于字符串型的数组，按照字母的顺序排列

    arr3.foreach(println)
  }

}

sortWith函数

object w21 {
  /**
   * sortWith函数
   * 自定义排序规则。
   */
  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)
  }
}