Scala匿名函数Lambda表达式详解

1 前言

大家好，我是楚生辉，在未来的日子里我们一起来学习大数据相关的技术，一起努力奋斗，遇见更好的自己！

本文详细的介绍了

scala的匿名函数

，有需要的小伙伴可以学习~

Scala 中定义匿名函数的语法很简单，箭头左边是参数列表，右边是函数体。

使用匿名函数后，我们的代码变得更简洁了,让我们程序员估计关注于逻辑处理

下面的表达式就定义了一个接受一个Int类型输入参数,返回值为

x+1

匿名函数:

(x:Int)=> x+1

2.快速入门

没有名字的函数就是匿名函数。

(x:Int)=>{函数体}

x：表示输入参数类型；Int：表示输入参数类型；函数体：表示具体代码逻辑

在快速入门的案例中，我们定义了一个dualFunction函数，在这个函数中，传入一个函数作为参数，实现简单的加减运算

def main(args: Array[String]):Unit={// 定义一个二元运算函数，只操作1与2两个数，但是具体的运算通过参数传递def dualFunction(fun:(Int,Int)=>Int):Int={
        fun(1,2)}// 定义 add与minus两个匿名函数val add =(a:Int,b:Int)=> a + b
    val minus =(a:Int,b:Int)=> a - b

    println(dualFunction(add))
    println(dualFunction(minus))// 或者我们可以直接把匿名函数定义在参数中
    println(dualFunction((a:Int,b:Int)=> a + b))
    println(dualFunction((a:Int,b:Int)=> a - b))// 因为a与b只出现过一次，所以直接可以用_来代替，如果顺序是b-a，我们可以转化为// -a + b  也即 -_ + _
    println(dualFunction(_ + _))
    println(dualFunction(_ - _))}

3.案例实操

3.1 传递一个参数

需求 1：传递的函数有一个参数

传递匿名函数至简原则：

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

def main(args: Array[String]):Unit={// （1）定义一个函数：参数包含数据和逻辑函数def operation(arr: Array[Int], op:Int=>Int)={for(elem <- arr)yield op(elem)}// （2）定义逻辑函数def op(ele:Int):Int={
        ele +1}// （3）标准函数调用val arr = operation(Array(1,2,3,4), op)
    println(arr.mkString(","))// （4）采用匿名函数val arr1 = operation(Array(1,2,3,4),(ele:Int)=>{
        ele +1})
    println(arr1.mkString(","))// （4.1）参数的类型可以省略，会根据形参进行自动的推导;val arr2 = operation(Array(1,2,3,4),(ele)=>{
        ele +1})
    println(arr2.mkString(","))// （4.2）类型省略之后，发现只有一个参数，则圆括号可以省略；其他情况：没有参数和参数超过 1 的永远不能省略圆括号。val arr3 = operation(Array(1,2,3,4), ele =>{
        ele +1})
    println(arr3.mkString(","))// (4.3) 匿名函数如果只有一行，则大括号也可以省略val arr4 = operation(Array(1,2,3,4), ele => ele +1)
    println(arr4.mkString(","))//（4.4）如果参数只出现一次，则参数省略且后面参数可以用_代替val arr5 = operation(Array(1,2,3,4), _ +1)
    println(arr5.mkString(","))}

3.2 传递两个参数

需求 2：传递的函数有两个参数

object TestFunction {def main(args: Array[String]):Unit={def calculator(a:Int, b:Int, op:(Int,Int)=>Int):Int={
            op(a, b)}// （1）标准版
        println(calculator(2,3,(x:Int, y:Int)=>{x + y}))// （2）如果只有一行，则大括号也可以省略
        println(calculator(2,3,(x:Int, y:Int)=> x + y))// （3）参数的类型可以省略，会根据形参进行自动的推导;
        println(calculator(2,3,(x , y)=> x + y))// （4）如果参数只出现一次，则参数省略且后面参数可以用_代替
        println(calculator(2,3, _ + _))}}

3.3 多层嵌套函数

定义一个函数func，它接受一个一个Int类型的参数，返回一个函数f1,它返回的函数fi，接受一个String类型的参数，同样返回一个函数f2，函数f2接收一个Char类型的参数，返回一个Boolean的值,如果传入0，空字符串，0就返回false

def main(args: Array[String]):Unit={def func(i:Int):String=>(Char=>Boolean)={def f1(s:String):Char=>Boolean={def f2(c:Char):Boolean={if(i ==0&& s ==""&& c =='0')falseelsetrue}
            f2
        }
        f1
    }
    println(func(0)("")('0'))
    println(func(0)("")('1'))}// 返回值为 falsetrue

func(0)("")('0')

func(0)代表f1，func(0)(“”)则代表的f2