函数的应用：以函数作为参数(重点)

以函数作为参数、以函数中作为返回值
统称为高阶函数

package com.shujia.scala

object Demo15 {
  def main(args: Array[String]): Unit = {
    /**
     * 以函数作为参数
     *
     * f:是一个参数为String类型、返回值为Int类型的函数
     * fun1是一个参数为f，没有返回值的函数
     *
     */
    //定义一个函数，(参数为String类型、返回值为Int类型的函数)作为定义函数的参数
    def fun1(f:String => Int):Unit= {
      //在定义的函数内，调用传入进来的函数
      val i: Int = f("666")
      println(i)  //666
    }

    //定义一个函数，作为调用fun1函数时需要传入的参数
    def f1(str:String):Int = {
      str.toInt
    }

    //调用定义的函数fun1,需要传入一个参数为String类型、返回值为Int类型的函数
    fun1(f1)

  }
}

执行顺序

scala 类 成员函数多态 scala 函数作为参数_数组

使用lambda格式作为参数

package com.shujia.scala

object Demo15 {
  def main(args: Array[String]): Unit = {
    /**
     * 以函数作为参数
     *
     * f:是一个参数为String类型、返回值为Int类型的函数
     * fun1是一个参数为f，没有返回值的函数
     *
     */
    //定义一个函数，(参数为String类型、返回值为Int类型的函数)作为定义函数的参数
    def fun1(f:String => Int):Unit= {
      //在定义的函数内，调用传入进来的函数
      val i: Int = f("666")
      println(i)  //666
    }

    //使用lambda格式作为参数
    fun1((str:String) => str.toInt)
      
    //lambda的参数类型可以省略，lambda表达式参数类型会自动推断
//    fun1(s => s.toInt)
      
    //如果lambda的参数只使用了一次可以使用下划线代替
//    fun1(_.toInt)
  }
}
以函数作为参数应用举例

案例1

package com.shujia.scala

object Demo15 {
  def main(args: Array[String]): Unit = {
    //定义一个数组
    val arr: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8)

    arr.foreach((i:Int) =>{
      println(i + 2)  //3 4 5 6 7 8 9 10  (实际是一行一个元素，这样写方便查看)
    })
    /**
     * foreach：一行一行遍历数组中的元素, 将数组中的元素一个一个传递给后面的函数
     * foreach 将循环之后需要做的处理交给调用者，调用者传一个函数进去
     */

    //简写
    arr.foreach(i=>println(i+2))  //3 4 5 6 7 8 9 10  (实际是一行一个元素，这样写方便查看)

    //再简写(这种简写只能遍历原始的元素，无法对元素进行操作)
    arr.foreach(println)  //1 2 3 4 5 6 7 8   (实际是一行一个元素，这样写方便查看)

    /**
     * println 是一个参数为Any 没有返回值的函数
     * arr.foreach 需要的是参数为Int、没有返回值的函数（刚好可以传入 println）
     *
     * scala函数的调用也符合多态的思想
     */
  }
}

案例2

需求：将数组中的数据都加2

object Demo18 {
  def main(args: Array[String]): Unit = {
    //定义一个数组
    val arr = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)

    //方法1：利用Java的格式
    var i = 0
    while (i < arr.length) {
      arr(i) = arr(i) + 2
      i += 1
    }
    arr.foreach(println)  //3 4 5 6 7 8 9 10 11
  }
}
object Demo18 {
  def main(args: Array[String]): Unit = {
    //定义一个数组
    val arr = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)
      
    //方法2：Scala的方式：map
    /**
     * map: 将数组中的元素一个一个传递给后面的函数
     * map 会将后面的函数的返回值构建成一个新的数组
     * 返回一个新的数组
     */
    val arr2: Array[Int] = arr.map((i: Int) => i + 2)
    arr2.foreach(println)
  }
}

需求：将数组中的元素奇数加1，偶数乘以2

object Demo18 {
  def main(args: Array[String]): Unit = {
    //定义一个数组
    val arr = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)

val arr3: Array[Int] = arr.map((i: Int) => {
      if (i % 2 == 1) {
        i + 1
      } else {
        i * 2
      }
    })
    arr3.foreach(println) //2 4 4 8 6 12 8 16 10
  }
}