Scala 高阶函数 (八)

Scala 中的高阶函数，函数式编程，开发时候不用过多的关注实现，只关注结果

匿名函数

语法：参数列表 => 函数体

柯里化函数

语法：def sum(x:Int)(y:Int) = x+y

函数对象

在scala中内置了23个函数对象，分别是Function0~Function22

函数对象作为参数

注意：

Scala的函数对象可以作为引用进行传递，原因函数也是对象

package function

object HighOrderFunction {
  def main(args: Array[String]): Unit = {
    // 函数对象
    val f2 = (x: Int, y: Int) => x + y

    sum(10,20,f2)
  }


  def sum(x: Int, y: Int, f2: Function2[Int, Int, Int]): Int = {
    f2(x,y)
  }

}

参数（类型）推断

package function

/**
  * 参数（类型）推断
  */
object HighOrderFunction2 {
  def main(args: Array[String]): Unit = {
    val arr = Array[Int](1, 2, 3, 4, 5)
    //    val f1 = (x:Int) => println(x)
    //    arr.foreach(f1)

    // 完整写法
    arr.foreach((x: Int) => println(x))

    println("------------------------------")
    // 简化 元素类型
    arr.foreach((x) => println(x))

    println("++++++++++++++++++++++++++++++")
    // 简化 参数列表 只有单个参数 省略 ()
    arr.foreach(x => println(x))

    println("==============================")
    // 简化 x => 省略  _ 匹配数组中每一个元素
    arr.foreach(println(_))

    println("==============================")
    arr.foreach(println)
  }
}

高阶函数

链式调用

package function

/**
  * 参数（类型）推断
  */
object HighOrderFunction3 {
  def main(args: Array[String]): Unit = {
    // 单词统计
    val arr = Array[String]("Hello Hadoop", "Hello Kafka")

    // 标准写法
    arr
      .flatMap((line: String) => line.split("\\s"))
      .filterNot((word: String) => "Kafka".equals(word))
      .map((word: String) => (word, 1L)) // ArrayList[Object](word,1L)  Tuple2
      .groupBy((t2: Tuple2[String, Long]) => t2._1)
      .map((t2: Tuple2[String, Array[Tuple2[String, Long]]]) => (t2._1, t2._2.length))
      .foreach(println)

    println("-----------------------------------")
    // 简化写法
    arr
      .flatMap(_.split("\\s"))
      .filterNot("Kafka".equals(_))
      .map((_, 1L))
      .groupBy(_._1)
      .map(t2 => (t2._1,t2._2.length))
      .foreach(println)
  }
}

函数闭包

闭包指在函数体内，可以访问相应作用域内的任何变量，因为它引用到函数外面定义的变量，定义这个函数的过程是将这个自由变量捕获而构成一个封闭的函数。

语法:函数对象 + 外部变量 = 闭包

package function

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

    var n = 0

    // 函数闭包： 函数对象 + 外部变量 = 闭包
    val f1 = (x: Int) => x + n

    println(f1(1))

    n = 100 // 函数对象闭包后，只保存一个外部变量的引用地址，当外部的变量在发生改变时，会影响到闭包后的结果

    println(f1(2))
  }
}