学习Scala_第九篇笔记

2022-01-28 19:03:33 阅读：175 来源： 互联网

标签：Scala Int 笔记第九篇 Unit println Array foo def

高阶函数案例
需求：模拟 Map 映射、Filter 过滤、Reduce 聚合

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) ={
 var arr1:ArrayBuffer[Int] = ArrayBuffer[Int]()
 for(elem <- arr if op(elem)){
 arr1.append(elem)
 }
 arr1.toArray
 }
 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) = {
 // 函数柯里化，其实就是将复杂的参数逻辑变得简单化,函数柯里化一定存在闭包
 def f3()(b:Int)={
 a + b
 }
 println(f3()(3))
 } }

控制抽象
1）值调用：把计算后的值传递过去

object TestControl {
 def main(args: Array[String]): Unit = {
 def f = ()=>{
 println("f...")
 10
 }
 foo(f())
 }
 def foo(a: Int):Unit = {
 println(a)
 println(a)
 } }

2）名调用：把代码传递过去

object TestControl {
def main(args: Array[String]): Unit = {
def f = ()=>{
println("f...")
10
}
foo(f())
}
//def foo(a: Int):Unit = {
def foo(a: =>Int):Unit = {//注意这里变量 a 没有小括号了
println(a)
println(a)
} }
输出结果：
f...
10
f...
10

注意：Java 只有值调用；Scala 既有值调用，又有名调用。

object TestFunction {
 def main(args: Array[String]): Unit = {
 // （1）传递代码块
 foo({
 println("aaa")
 })
 // （2）小括号可以省略
 foo{
 println("aaa")
 }
 }
 def foo(a: =>Unit):Unit = {
 println(a)
 println(a)
 } }

自定义一个 While 循环

object TestFunction {
 def main(args: Array[String]): Unit = {
 var i:Int = 1
 myWhile(i <= 10){
 println(i)
 i +=1
 }
 }
 def myWhile(condition: =>Boolean)(op: =>Unit):Unit={
 if (condition){
 op
 myWhile(condition)(op)
 }
 } }

惰性加载
1）说明
当函数返回值被声明为 lazy 时，函数的执行将被推迟，直到我们首次对此取值，该函
数才会执行。这种函数我们称之为惰性函数。
2）案例实操

def main(args: Array[String]): Unit = {
 lazy val res = sum(10, 30)
 println("----------------")
 println("res=" + res)
}
def sum(n1: Int, n2: Int): Int = {
 println("sum 被执行。。。")
 return n1 + n2
}

输出结果：
----------------
sum 被执行。。。
res=40

注意：lazy 不能修饰 var 类型的变量

标签：Scala,Int,笔记,第九篇,Unit,println,Array,foo,def
来源： https://blog.csdn.net/qq_36490525/article/details/122734697

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

学习Scala_第九篇笔记