Scala 高级函数（一）

一、高阶函数

定义函数，调用函数

object TestFunction {
def main(args: Array[String]): Unit = {
    // 调用函数
foo()
}
// 定义函数
def foo():Unit = {
    println("foo...")
  }
}

函数作为值进行传递

object TestFunction {

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

    //（1）调用foo函数，把返回值给变量f（因为推断不出来是把函数整体赋值给f）
    //val f = foo()
    val f = foo
    println(f)

    //（2）在被调用函数foo后面加上_，相当于把函数foo当成一个整体，传递给变量f1
    val f1 = foo _

    foo()
    f1()
}

def foo():Int = {
    println("foo...")
    1
  }
}

函数作为参数进行传递

def main(args: Array[String]): Unit = {
    
// （1）定义一个函数，函数参数是一个函数签名；f表示输入函数名称;(Int,Int)表示输入两个Int参数；Int表示函数返回值
def f1(f: (Int, Int) => Int): Int = {
    f(2, 4)
}

// （2）定义一个函数，参数和返回值类型和f1的输入参数一致
def add(a: Int, b: Int): Int = a + b

// （3）将add函数作为参数传递给f1函数，如果能够推断出来不是调用，_可以省略
println(f1(add))
println(f1(add _))
}

函数可以作为函数返回值进行返回

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

println("f1")

    def f2(s:String) = {
println(s + "f2")

  }
f2 _
 }

val f = f1()
// 因为f1函数的返回值依然为函数，所以可以变量f可以作为函数继续调用
f("")
// 上面的代码可以简化为
f1()("")
}

二、匿名函数

（1）参数的类型可以省略，会根据形参进行自动的推导
（2）类型省略之后，发现只有一个参数，则圆括号可以省略；其他情况：没有参数和参数超过1的永远不能省略圆括号。
（3）匿名函数如果只有一行，则大括号也可以省略
（4）如果参数只出现一次，则参数省略且后面参数可以用_代替

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

    // （1）定义一个函数：参数包含数据和逻辑函数
    def f(arr: Array[Int], op: Int => Int) = {
        for (elem <- arr) yield op(elem)
    }

    // （2）定义逻辑函数
    def op(ele: Int): Int = {
        ele + 1
    }

    // （3）标准函数调用
    val arr = f(Array(1, 2, 3, 4), op)
    println(arr.mkString(","))

    // （4）采用匿名函数
    val arr1 = f(Array(1, 2, 3, 4), (ele: Int) => {
        ele + 1
    })
    println(arr1.mkString(","))

    // （4.1）参数的类型可以省略，会根据形参进行自动的推导;
    val arr2 = f(Array(1, 2, 3, 4), (ele) => {
        ele + 1
    })
    println(arr2.mkString(","))

    // （4.2）类型省略之后，发现只有一个参数，则圆括号可以省略；其他情况：没有参数和参数超过1的永远不能省略圆括号。
    val arr3 = f(Array(1, 2, 3, 4), ele => {
        ele + 1
    })
    println(arr3.mkString(","))

    // (4.3) 匿名函数如果只有一行，则大括号也可以省略
    val arr4 = f(Array(1, 2, 3, 4), ele => ele + 1)
    println(arr4.mkString(","))

    //（4.4）如果参数只出现一次，则参数省略且后面参数可以用_代替
    val arr5 = f(Array(1, 2, 3, 4), _ + 1)
    println(arr5.mkString(","))
    }
}

传递的函数有两个参数

object TestFunction {

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

    def f(a: Int, b: Int, op: (Int, Int) => Int): Int = {
        op(a, b)
    }

    // （1）标准版
    println(f(2, 3, (x: Int, y: Int) =>  {x + y}))

    // （2）如果只有一行，则大括号也可以省略
    println(f(2, 3, (x: Int, y: Int) =>  x + y))

    // （3）参数的类型可以省略，会根据形参进行自动的推导;
    println(f(2, 3, (x , y) =>  x + y))

    // （4）如果参数只出现一次，则参数省略且后面参数可以用_代替
    println(f(2, 3,   _ + _))
   }
}

匿名函数例子

object TestFunction {

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

    // （1）map映射
    def map(arr: Array[Int], op: Int => Int) = {
        for (elem <- arr) yield op(elem)
    }

    val arr = map(Array(1, 2, 3, 4), (x: Int) => {
        x * x
    })
    println(arr.mkString(","))

    // （2）filter过滤。有参数，且参数再后面只使用一次，则参数省略且后面参数用_表示
    def filter(arr: Array[Int], op: Int => Boolean) = {
        for (elem <- arr) yield op(elem)
    }

    filter(Array(1, 2, 3, 4), x => x % 2 == 1)
    var arr1 = filter(Array(1, 2, 3, 4), _ % 2 == 1)
    println(arr1.mkString(","))

    // （3）reduce聚合。有多个参数，且每个参数再后面只使用一次，则参数省略且后面参数用_表示，第n个_代表第n个参数
    def reduce(arr: Array[Int], op: (Int, Int) => Int) = {

        var init: Int = arr(0)

        for (elem <- 1 until arr.length) {
            init = op(init, arr(elem))
        }
        init
    }

    //val arr2 = reduce(Array(1, 2, 3, 4), (x, y) => x + y)
    val arr2 = reduce(Array(1, 2, 3, 4), _ + _)
    println(arr2)
   }
  }