scala 匿名函数案例详解

1.匿名函数含义

@1.说明

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

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

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

1.1传递匿名函数含义

@2.传递匿名函数至简原则：

（1）参数的类型可以省略，会根据形参进行自动的推导

（2）类型省略之后，发现只有一个参数，则圆括号可以省略；其他情

况：没有参数和参数超过 1 的永远不能省略圆括号。

（3）匿名函数如果只有一行，则大括号也可以省略

（4）如果参数只出现一次，则参数省略且后面参数可以用_代替

1.2传递匿名函数第一层代码解析

小编在此将代码分为：“第一层”和“第二层”,方便大家理解：

          和匿名函数的相爱相杀,
                               各位看官，正片开始。

-slaca第一层

//需求：传递的函数有两个参数
//函数含义：传递两个数，并对两个数进行相加的逻辑操作
def calculator(a: Int, b: Int, sum: (Int, Int) => Int): Int = {
 sum(a, b)
 }

【函数具体解析】——小编提示：一定要先看懂3.2再看后面

@3.1 首先定义一个函数：参数包含 “数据” 和 “逻辑函数”

@3.2 第一层的时候 只需要声名《“数据”的类型》 或《 “逻辑函数”的参数

类型和返回值类型，

1.(a: Int, b: Int) ------------------->数据的类型

2.(sum: (Int, Int) => Int)--------->逻辑函数的参数类型和返回值类型

3.sum(a, b)：比较复杂，喝口水再来看，乖！但是记住：是水不是口水！

3.1：首先 “传递匿名函数”中的 逻辑是对数据的操作

3.2：那么可以理解为“传递匿名函数” 的数据就是为逻辑准备的

3.3 ：所以逻辑函数就得包含数据，就有了(x:Int)=>{函数体} 中函数体包
含sum(a, b)，这样才能进行 对数据的逻辑操作

退一万步来讲，逻辑跟尼玛数据分开，还操作个锤子

所以sum(a, b) ->第一层的最后操作：逻辑与数据的结合(跟那爱情一样是
吧。听懂掌声，为爱鼓掌)就在这完成了。

@3.3 第二层的时候 才传递 《数据----->真实的数据》 《逻辑函数----->真

正的逻辑》

3.1 这其实跟 “java”特别像

小编也在此将代码分为：“第一层”和“第二层”,方便大家理解：

@4.1 Java第一层
Java是先声明一个方法：也以传递两个数字，并进行相加 为例

public static int add(int a,int b){
        return a+b;
    }

1（int:a,int:b）----> 参数

2 a+b---->方法体 ：此处也是省了类型，因为参数已经声明过了

@4.2java第二层

等到调用时，才传递数据

add(2,3);

1.add(1,2) —> 此处省了逻辑，因为方法体中声明过

2.想必看到这儿，大家已经有了心中的小九九，接下来大家跟小编一起看

看最后的思路吧

3.2传递匿名函数第二层代码解析

// （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, _ + _))

想必看到这儿，各位看官的思绪就像…那句话咋说来着，忘求了。让我百度下下

玛德，搜了半天没搜到，略过…略过…

小编提示：没有思绪的可以在看两遍，琢磨琢磨！！！

正片开始：不是苍老师哦！

scala第二层：

1.数据---->真正的数据

2.逻辑---->真正的逻辑

3.第一层的 sum(a, b)已经完成了逻辑包含数据的操作,当第二层传递完数

据，这部分就真正的完成了。剩下的就是看逻辑怎么对数据进行操作

3.1 x: Int, y: Int) => x + y ---->(x , y) => x + y 省类型：会根据形参进行自动的推导。没什么独特的，java也是一样的：（参数有类型，方法体中省了的）

3.2 a: Int, b: Int—>2, 3 结合Scala 一二层的参数看
int a,int b-------->2,3 结合Java 一二层的参数看
从这儿我们可以看出 只要知道参数的名，和类型 即可 直接给值

3.3 (Int, Int) => Int----->_ + _ 单从这儿和3.2可以理解为 把参数名写为"_"可能是scala的一个特色嘛，因为从3.2得知 需要参数名和类型，才能直接给值嘛。

3.4 但是我们在 第一层的函数块中写的是 sum(a,b)这里省了类型，因为可以从参数a: Int, b: Int得到参数名的类型，所以我们的"+"是基于 sum(a,b) 做的推断，此时参数名，参数类型都有了，就可以直接传值了，但是说白了，这个参数名是固定的，再怎么给值，也不能变。所以scala为了简写，就用“_”代替了

以上文章仅小编个人见解，如有错误，请大家畅所欲言。请各位dai佬谅解

<小编也只学了十来天scala,所以有很多不足的地方，请指出，谢谢大家了

同时小编写的不易，从八点开始写，写道12点，中间吃了个饭。也请大家

补充：scala匿名函数案例

匿名函数

Scala提供了一个相对轻量级的语法来定义匿名函数。源代码中的匿名函数称为函数文字，在运行时，函数文字被实例化为称为函数值的对象。Scala支持一级函数，函数可以用函数文字语法表达，即(x：Int)=> x + 1，该函数可以由一个叫作函数值的对象来表示。

基本介绍

没有名字的函数就是匿名函数，可以通过函数表达式 来设置匿名函数。

匿名函数（也称为 lambda）是作为参数传递给高阶函数的代码块。 维基百科将 匿名函数 定义为“未绑定到标识符的函数定义”。

应用实例

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

使用匿名函数后，我们的代码变得更简洁了。

下面的表达式就定义了一个接受一个 Double 类型输入参数的匿名函数:

val triple = (x:Double) => 3*x
println(triple(3))

说明：

• (x:Double) => 3 * x 就是匿名函数
• (x:Double) 是形参列表，=> 是规定语法表示后面是函数体，3 * x 就是函数体，如果有多行，可以 {} 换行写。
• triple 是指向匿名函数的变量。

一旦你熟悉了 Scala，你就会一直使用这种形式来编写匿名函数，这些函数在函数的一个位置使用一个变量。 但如果你愿意，你也可以用更长的形式来写它们

val doubledInts = ints.map((i: Int) => i * 2)

因为 Scala 编译器可以从 ints 中的数据推断 i 是一个 Int，所以可以删除 Int 声明：

val doubledInts = ints.map((i) => i * 2)

因为只有一个参数，所以不需要在参数 i 周围的括号：

val doubledInts = ints.map(i => i * 2)

因为当参数在函数中只出现一次时，Scala 允许您使用 _ 符号而不是变量名，所以代码可以进一步简化：

val doubledInts = ints.map(_ * 2)

案例

请编写一个匿名函数，可以返回2个整数的和，并输出该匿名函数的类型。

val f1 = (n1: Int, n2: Int ) => {
    println("匿名函数被调用")
    n1 + n2
}
println("f1类型=" + f1)
println(f1(10, 30))

到此这篇关于scala 匿名函数详解的文章就介绍到这了,更多相关scala 匿名函数内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

最新评论