Scala入门到精通(尚硅谷学习笔记)章节七——函数式编程

scala支持两种编程范例&＃xff1a;面向对象编程&＃xff08; OOP &＃xff09;和函数编程&＃xff08; FP &＃xff09;。
函数式编程在解决问题时&＃xff0c;将问题分解成一个一个的步骤&＃xff0c;将每个步骤进行封装(函数)&＃xff0c;通过调用这些封装好的步骤&＃xff0c;解决问题。
在 Scala 当中&＃xff0c;函数既可以作为函数的参数使用&＃xff0c;也可以将函数赋值给一个变量. &＃xff0c;函数的创建不用依赖于类或者对象。

如果不写等于号和方法主体&＃xff0c;那么方法会被隐式声明为抽象(abstract)&＃xff0c;包含它的类型于是也是一个抽象类型。

1. 函数在scala语言中&＃xff0c;是函数编程的 “头等公民”
2. 方法是 scala 面向对象中的概念&＃xff0c;主要定义在类&＃xff0c;特质&＃xff0c;抽象类中
3. 函数是一个对象&＃xff0c;方法本质就是类中的一个普通的方法
4. 函数可以作为参数进行传递,可以作为返回值返回,但是方法不行
5. 方法可以通过一定的语法转成函数
   参考博文&＃xff1a;https://blog.csdn.net/mswuxianshen/article/details/84

def main(args: Array[String]): Unit &＃61; {//定义函数def sayHi(name:String):Unit &＃61; {println("hi,"&＃43;name)}//调用函数sayHi(name &＃61;"alice")//调用对象方法this.sayHi(NAME&＃61;"Bob")}//定义对象的方法def sayHi(name:String):Unit &＃61; {println("Hi,"&＃43;name)}

返回值

(1)函数1:无参&＃xff0c;无返回值

def f1():Unit &＃61;{println("1.无参&＃xff0c;无返回值")}//调用f1()


(2)函数2:无参&＃xff0c;有返回值

def f2():Int &＃61;{println("1.无参&＃xff0c;有返回值")return 12}//调用println(f2())//12


(3)函数3:有参&＃xff0c;无返回值

def f3(name:String):Unit &＃61;{println("3.有参&＃xff0c;无返回值"&＃43;name)//输出&＃xff1a;有参&＃xff0c;无返回值alice}println(f3(name&＃61;"alice" ))//输出&＃xff1a;()


(4)函数4:有参&＃xff0c;有返回值

def f3(name:String):String &＃61;{println("3.有参&＃xff0c;无返回值"&＃43;name)//输出&＃xff1a;有参&＃xff0c;无返回值alicereturn "hi,"&＃43;name}println(f3(name&＃61;"alice" ))//输出&＃xff1a;hi,alice

可变参数

Scala 允许指明函数的最后一个参数可以重复&＃xff0c;即我们不需要指定函数参数的个数&＃xff0c;可以向函数传入可变长度参数列表。
Scala 通过在参数的类型之后放一个星号来设置可变参数(可重复的参数)。

def f1(str:String*):Unit &＃61;{println(str)}f1(str&＃61;"alice")//WrappedArray(alice)f1("aaa","bbb","ccc")//WrappedArray(aaa, bbb, ccc)


如果参数列表中存在多个参数,那么可变参数一般放置在最后

def f1(str1:String,str2:String*):Unit &＃61;{println("str1 "&＃43;str1&＃43;"str2 "&＃43;str2)}f1(str1&＃61;"alice")//str1 alicestr2 WrappedArray()f1("aaa","bbb","ccc")//str1 aaastr2 WrappedArray(bbb, ccc)


参数默认值&＃xff0c;一般将有默认值的参数放置在参数列表的后面

def f1(str:String&＃61;"Heria"):Unit &＃61;{println("My name is "&＃43;str)}f1("Java")//My name is Javaf1()//My name is Heria

函数至简原则&＃xff1a;能省则省

现有原始长度函数

def f0(name:String):String &＃61;{return name}println(f0("Heria"))


一、return可以省略&＃xff0c;Scala 会使用函数体的最后一行代码作为返回值

def f1(name:String):String &＃61;{name}println(f1("Heria"))


二、如果函数体只有一行代码&＃xff0c;可以省略花括号

def f2(name:String):String &＃61;nameprintln(f2("Heria"))


三、返回值类型如果能够推断出来&＃xff0c;那么可以省略&＃xff08;:和返回值类型一起省略)

def f3(name:String) &＃61;nameprintln(f3("Heria"))


四、如果有return&＃xff0c;则不能省略返回值类型&＃xff0c;必须指定
五、如果函数明确声明unit&＃xff0c;那么即使函数体中使用return关键字也不起作用
六、Scala如果期望是无返回值类型&＃xff0c;可以省略等号

def f6(name:String){println("Heria")}


七、如果函数无参&＃xff0c;但是声明了参数列表&＃xff0c;那么调用时&＃xff0c;小括号&＃xff0c;可加可不加

def f7():Unit&＃61;{println("Heria")}f7


八、如果函数没有参数列表&＃xff0c;那么小括号可以省略&＃xff0c;调用时小括号必须省略

def f8:Unit&＃61;{println("Heria")}f8


九、如果不关心名称&＃xff0c;只关心逻辑处理&＃xff0c;那么西数名(def)可以省略

//匿名函数&＃xff0c;lambda表达式
(name:String)&＃61;>{println(name)}

匿名函数

Scala支持一级函数&＃xff0c;函数可以用函数文字语法表达

//匿名函数&＃xff0c;lambda表达式
val fun &＃61; (name:String)&＃61;>{println(name)}
//val stringToUnit: String &＃61;> Unit &＃61; (name:String) &＃61;> {println(name)}
//以String作为参数&＃xff0c;Unit作为返回值的函数
fun("Heria")


匿名函数的主要作用是作为参数参与函数的运行

val fun &＃61; (name:String)&＃61;>{println(name)}
def f(func:String&＃61;>Unit):Unit&＃61;{func("Heria")
}
f(fun)


为什么这个函数可以直接打印&＃xff1f;因为f函数调用了func这个作为参数的函数&＃xff0c;而我们在调用f函数时&＃xff0c;是将fun函数作为参数传入的。fun函数需要传入String类型的参数&＃xff0c;func("Heria")将Heria作为参数传入。
f()这种类型的函数的目的是为了针对固定的数据&＃xff0c;传入不同的函数对数据进行操作
匿名函数的简化原则

f((name:String)&＃61;>{println(name)})


一、参数的类型可以省略,会根据形参进行自动的推导

f((name)&＃61;>{println(name)})


二、类型省略之后&＃xff0c;发现只有一个参数&＃xff0c;则圆括号可以省略;没有参数和参数超过一的永远不能省略括号。

f(name&＃61;>{println(name)})


三、匿名函数如果只有一行,则大括号也可以省略

f(name&＃61;>println(name))


四、如果参数只出现一次,则参数省略且后面参数可以用_代替

f(println(_))


五、如果可以推断出&＃xff0c;当前传入的println是一个函数体&＃xff0c;而不是调用语句&＃xff0c;可以直接省略下划线

f(println)


案例实操1
定义一个”二元运算函数&＃xff0c;只操作1和2两个数&＃xff0c;但是具体运算通过参数传入

def dualFunctionOneAndTwo(fun:(Int,Int)&＃61;>Int):Int&＃61;{fun(1,2)
}
//1
val add &＃61;(a:Int,b:Int)&＃61;>a&＃43;b
println(dualFunctionOneAndTwo(add)//2
println(dualFunctionOneAndTwo((a:Int,b:Int)&＃61;>a&＃43;b))//3
println(dualFunctionOneAndTwo((a,b)&＃61;>a&＃43;b))//4
println(dualFunctionOneAndTwo(_&＃43;_))


案例实操2
定义一个函数func&＃xff0c;它接收一个Int类型的参数&＃xff0c;返回一个函数(记作fl1)。
它返回的函数f1&＃xff0c;接收一个string类型的参数&＃xff0c;同样返回一个函数&＃xff08;记作2)。函数f2接
收一个Char类型的参数&＃xff0c;返回一个Boolean的值。
要求调用函数func(0)(“”)(0)得到返回值为false&＃xff0c;其它情况均返回true。
简化前

def func(i: Int): String&＃61;>(Char&＃61;>Boolean) &＃61; {def f1(s: String): Char&＃61;>Boolean &＃61; {def f2(c: Char): Boolean &＃61; {if (i &＃61;&＃61; 0 && s &＃61;&＃61; "" && c &＃61;&＃61; &＃39;0&＃39;) false else true}f2}f1
}
println(func(0)("")(&＃39;0&＃39;))//false


简化后

def func(i: Int): String&＃61;>(Char&＃61;>Boolean) &＃61; {s&＃61;>c&＃61;>if (i &＃61;&＃61; 0 && s &＃61;&＃61; "" && c &＃61;&＃61; &＃39;0&＃39;) false else true
}
println(func(0)("")(&＃39;0&＃39;))//false


柯里化

def func(i:Int)(s:String)(c:Char):Boolean&＃61;{if(i&＃61;&＃61;0 && s&＃61;&＃61;"" && c&＃61;&＃61;"0") false else true
}

高阶函数

高阶函数将其他函数作为参数或其结果是函数的函数。

一、函数作为值进行传递

def f(n:Int):Int&＃61;{println("f调用")n&＃43;1
}//val f1:Int&＃61;>Int&＃61;f
val f2 &＃61;f _


二、函数作为参数进行传递

def dualEval(op:(Int,Int)&＃61;>Int,a:Int,b:Int):Int&＃61;{op(a,b)}def add(a:Int,b:Int):Int&＃61;{a&＃43;b}println(dualEval(add,1,2))println(dualEval((a,b)&＃61;>a&＃43;b,1,2))println(dualEval(_&＃43;_,1,2))


三、函数作为返回值返回

def f5(): Int&＃61;>Unit &＃61; {def f6(a: Int): Unit &＃61; {println("f6调用" &＃43;a)}f6 //将函数直接返回
}
//println(f5())//返回引用val f6 &＃61;f5()
println(f6)//输出&＃xff1a;
println(f6(25))
//输出&＃xff1a;f6调用25
// ()println(f5()(25))
//输出&＃xff1a;f6调用25
// ()


案例实操
对数组进行处理&＃xff0c;将操作抽象出来&＃xff0c;处理完毕之后的结果返回一个新的数组

val arr: Array [Int] &＃61; Array(12,45,75,98)
def array0peration(array: Array[Int],op: Int&＃61;>Int): Array[Int] &＃61; {for (elem <- array) yield op(elem)
}//定义一个加一操作
def add0ne(elem: Int): Int &＃61; {elem &＃43; 1
}//调用函数
val newArray: Array[Int] &＃61;array0peration(arr,add0ne)
println(newArray.mkString(" , "))//13 , 46 , 76 , 99
柯里化函数

以匿名函数案例实操2为例&＃xff0c;原代码为

def func(i: Int): String&＃61;>(Char&＃61;>Boolean) &＃61; {def f1(s: String): Char&＃61;>Boolean &＃61; {def f2(c: Char): Boolean &＃61; {if (i &＃61;&＃61; 0 && s &＃61;&＃61; "" && c &＃61;&＃61; &＃39;0&＃39;) false else true}f2}f1
}


该代码实现了函数的嵌套&＃xff0c;func的返回值是f1&＃xff0c;f1返回值是f2&＃xff0c;f2返回的是基于条件判断的布尔类型的值。输出时以println(func(0)("")(&＃39;0&＃39;))为例&＃xff0c;调用func函数&＃xff0c;传入参数0&＃xff0c;得到(Char&＃61;>Boolean)函数返回值&＃xff0c;相当于得到了f1的调用&＃xff0c;此时&＃xff0c;func的调用已经结束。i作为具备变量已经释放掉&＃xff0c;最终在f2中&＃xff0c;在语言理解层面是没办法取到i去做条件判断。
**闭包&＃xff1a;**能够读取其他函数内部变量的函数。在本质上&＃xff0c;闭包是将函数内部和函数外部连接起来的桥梁。
scala在调用函数时&＃xff0c;创建一个对象实例&＃xff0c;放到堆内存中。这个对象实例中打包了相关环境和局部变量。
案例实操
期望进行两树相加的操作&＃xff0c;其中一个数我们希望固定好&＃xff0c;但是熬以参数形式传入
变更前

def addBy4():Int&＃61;>Int&＃61;{val a &＃61; 4def add(b:Int):Int&＃61;{a&＃43;b}add
}


变更后

def addByA():Int&＃61;>Int&＃61;{val a &＃61; 4def add(b:Int):Int&＃61;{a&＃43;b}add
}
println(addByA(35)(24))val addByFour&＃61;addByA(4)
printlnaddByFour(12)


lamda表达式简化

def addByA(a:Int):Int&＃61;>Int &＃61; a &＃43; _


柯里化(Currying)函数是一个带有多个参数&＃xff0c;并引入到一个函数链中的函数&＃xff0c;每个函数都使用一个参数。函数柯里化的过程是把一个参数列表的多个参数&＃xff0c;变成多个参数列表。

def addCurrying(a:Int)(b:Int):Int&＃61;{a&＃43;b
}
println(addCurrying(35)(24))

递归

一个函数/方法体内又调用了自身称为递归调用。
阶乘案例

// 1&＃xff0e;循环实现def circle(n: Int) &＃61; {var result &＃61; 1for (i <- 1 to n) {result *&＃61; i}result}//2.递归实现def fact(n: Int):Int &＃61;{return fact(n-1)*n}


上述递归实现虽然能够极大简化程序员编写代码的量&＃xff0c;但是对计算机并不友好。return()会先拿到fact(n-1)的值&＃xff0c;再将n与之相乘。当调用下一层函数时&＃xff0c;内存仍保存有上一层的数据&＃xff0c;极大增加了内存的消耗。为了解决这个问题&＃xff0c;引入尾递归的概念,即指在一个方法内部&＃xff0c;递归调用后直接return&＃xff0c;没有任何多余的指令了。尾递归将外层方法的结果传递给了内层方法,当编译器检测到一个函数调用是尾递归的时候&＃xff0c;它就覆盖当前的活动记录而不是在栈中去创建一个新的。这样在计算fact(4)时&＃xff0c;会先将fact(5)弹栈&＃xff0c;再将fact(4)压栈&＃xff0c;保证同时只有一个栈帧在栈里存活

def tailFact(n: Int):Int &＃61;{&＃64;tailrecdef loop(n:Int,currRes:Int):Int&＃61;{if(n &＃61;&＃61; 0) return currResloop(n-1,currRes*n)}loop(n,1)
}

传值参数和传名参数

传值参数

如下案例所示&＃xff0c;定义一个Int类型的参数&＃xff0c;调用这个参数的时候就把Int类型的值传给它&＃xff0c;相当于变量赋值。

scala
def f0(a: Int): Unit &＃61; {println("a: " &＃43; a)println("a: " &＃43; a)}f0(23)


传名参数

将一部分代码或代码块作为整体传递给参数&＃xff0c;这个过程也叫名调用。

def x():Int&＃61;{println("x调用")12
}
def f1(a: &＃61;>Int): Unit &＃61; {println("a: " &＃43; a)println("a: " &＃43; a)
}
f1(x())


传名参数的这种调用方式是将a全部替换成x()代码块
案例实操&＃xff1a;自定义while循环
常规的while循环

var n: Int &＃61; 5
while (n >&＃61; 1) {println(n)n -&＃61; 1
}


用闭包实现一个函数&＃xff0c;将代码块作为参数传入&＃xff0c;递归调用

def mywhile(condition: &＃61;>Boolean): (&＃61;>Unit)&＃61;>Unit &＃61; {//内层函数需要递归调用&＃xff0c;参数就是符环体def doLoop(op: &＃61;> Unit): Unit &＃61; {if (condition) {opmywhile(condition)(op)}}doLoop _}n&＃61;10mywhile(n>&＃61;1){println(n)n-&＃61;1}}


用匿名函数实现

def mywhile(condition: &＃61;>Boolean): (&＃61;>Unit)&＃61;>Unit &＃61; {//内层函数需要递归调用&＃xff0c;参数就是符环体op&＃61;> {if (condition) {opmywhile(condition)(op)}}n&＃61;10mywhile(n>&＃61;1){println(n)n-&＃61;1}


柯里化实现

def mywhile(condition: &＃61;>Boolean)(op: &＃61;> Unit):Unit &＃61; {if (condition) {opmywhile(condition)(op)}}n&＃61;10mywhile(n>&＃61;1){println(n)n-&＃61;1}

惰性加载

当函数返回值被声明为lazy时&＃xff0c;函数的执行将被推迟&＃xff0c;直到我们首次对此取值&＃xff0c;该函
数才会执行。这种函数我们称之为惰性函数。
案例实操

lazy val result:Int&＃61;sum(13,47)println("1.函数调用")println("1.result&＃61;"&＃43;result)}def sum(a:Int,b:Int):Int&＃61;{println("3.sum调用")a&＃43;b//结果
//1.函数调用
//3.sum调用
//2.result&＃61;60


lazy使sum(13,47)的求值过程变成了懒加载的过程&＃xff0c;当前的result变量可以认为是传名参数&＃xff0c;只有在第一次调用的时候才会执行&＃xff08;只调用一次sum函数&＃xff09;