第四章 函数式编程
4.1 函数基础
4.1.1 函数基本语法
1）基本语法
2）案例实操
// 定义函数
def sayHi(name: String): Unit ={
println(s"hi, $name")
}
// 函数调用
sayHi("Tom")
4.1.2 函数与方法的区别
1）核心概念
（1）为完成某一功能的程序语句的集合，称为函数。
（2）类中的函数称之方法。
2）案例实操
（1）Scala语言可以在任何的语法结构中声明任何的语法
（2）函数没有重载和重写的概念；方法可以进行重载和重写
（3）Scala中函数可以嵌套定义
// （1）Scala语言可以在任何的语法结构中声明任何的语法
import java.util.Date
new Date()
// (2)函数没有重载和重写的概念，程序报错
def test(): Unit ={
println("无参，无返回值")
}
test()
def test(name:String):Unit={
println()
}
//（3）Scala中函数可以嵌套定义
def test2(): Unit ={
def test3(name:String):Unit={
println("函数可以嵌套定义")
}
}
4.1.3 函数定义
1）函数定义
（1）函数1：无参，无返回值
（2）函数2：无参，有返回值
（3）函数3：有参，无返回值
（4）函数4：有参，有返回值
（5）函数5：多参，无返回值
（6）函数6：多参，有返回值
2）案例实操
//（1）函数1：无参，无返回值
def f1(): Unit ={
println("1. f1")
}
f1()
val a = f1()
println(a)
//（2）函数2：无参，有返回值
def f2(): Int = {
println("2. f2")
return 2
}
f2()
println(f2())
//（3）函数3：有参，无返回值
def f3(name: String): Unit ={
println(s"3. f3 $name")
}
f3("Tom")
println(f3("Tom"))
//（4）函数4：有参，有返回值
def f4(name: String): String ={
println(s"4. f4 $name")
return "hello, " + name
}
f4("Tom")
println(f4("Tom"))
//（5）函数5：多参，无返回值
def f5(name1: String, name2: String): Unit ={
println(s"5. f5 $name1 $name2 都是我的好朋友")
}
f5("Tom", "Alice")
println(f5("Tom", "Alice"))
//（6）函数6：多参，有返回值
def f6(name1: String, name2: String): String ={
println(s"6. f6")
return s"$name1 $name2 都是我的好朋友"
}
f6("Tom", "Alice")
println(f6("Tom", "Alice"))
4.1.4 函数参数
1）案例实操
（1）可变参数
（2）如果参数列表中存在多个参数，那么可变参数一般放置在最后
（3）参数默认值，一般将有默认值的参数放置在参数列表的后面
（4）带名参数
2）案例实操
//（1）可变参数
def f1(str: String*): Unit ={
println(str)
}
f1("aaa", "bbb", "ccc")
//（2）如果参数列表中存在多个参数，那么可变参数一般放置在最后
def f2( str1: String, str2: String* ): Unit ={
println(s"str1: $str1 \t str2: $str2")
}
f2("aaa", "bbb", "ccc")
//（3）参数默认值，一般将有默认值的参数放置在参数列表的后面
def f3( name: String = "Tom" ): Unit ={
println(name)
}
f3("ShiLei")
f3()
//（4）带名参数
def f4( name: String = "Tom", sex: String, school: String = "Peking" ): Unit ={
println(s"name: $name \t sex: $sex \t school: $school")
}
f4("Alice", "女")
f4(sex = "男", school = "tsinghua", name = "Tom")
4.1.5 函数至简原则
函数至简原则：能省则省
1）至简原则细节
（1）return可以省略，Scala会使用函数体的最后一行代码作为返回值
（2）如果函数体只有一行代码，可以省略花括号
（3）返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略）
（4）如果有return，则不能省略返回值类型，必须指定
（5）如果函数明确声明unit，那么即使函数体中使用return关键字也不起作用
（6）Scala如果期望是无返回值类型，可以省略等号
（7）如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加
（8）如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略
（9）如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略
2）案例实操
// 正常定义函数
def f0(name: String): String = {
return name
}
// （1）return可以省略，Scala会使用函数体的最后一行代码作为返回值
def f1(name: String): String = {
name
}
// （2）如果函数体只有一行代码，可以省略花括号
def f2(name: String): String = name
// （3）返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略）
def f3(name: String) = name
// （4）如果有return，则不能省略返回值类型，必须指定
def f4(name: String): String = {
return name
}
// （5）如果函数明确声明unit，那么即使函数体中使用return关键字也不起作用
def f5(name: String): Unit = {
return name
}
println(f5("Peking"))
// （6）Scala如果期望是无返回值类型，可以省略等号
def f6(name: String) {
println("name")
}
// （7）如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加
def f7(): Unit ={
println("f7")
}
f7()
f7
// （8）如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略
def f8: Unit = {
println("f8")
}
f8
// （9）如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略
val f9 = (name: String) => println(name)
f9("Peking")
4.2 函数高级
4.2.1 匿名函数
1）说明
没有名字的函数就是匿名函数。
(x:Int)=>{函数体}
x：表示输入参数类型；Int：表示输入参数类型；函数体：表示具体代码逻辑
2）案例实操
需求1：传递的函数有一个参数
传递匿名函数至简原则：
（1）参数的类型可以省略，会根据形参进行自动的推导
（2）类型省略之后，发现只有一个参数，则圆括号可以省略；其他情况：没有参数和参数超过1的永远不能省略圆括号。
（3）匿名函数如果只有一行，则大括号也可以省略
（4）如果参数只出现一次，则参数省略且后面参数可以用_代替
// 定义一个匿名函数
val f = (name: String) => println(name)
f("Peking")
// 定义一个以函数作为参数的函数
def fun( f: (String) => Unit ): Unit ={
f("Tom")
}
fun(f)
// 匿名函数作为函数参数传入
fun( (name: String) => {
println(name)
})
// 匿名函数的简化
//（1）参数的类型可以省略，会根据形参进行自动的推导
fun( (name) => {
println(name)
})
//（2）类型省略之后，发现只有一个参数，则圆括号可以省略；其他情况：没有参数和参数超过1的永远不能省略圆括号。
fun( name => {
println(name)
})
//（3）匿名函数如果只有一行，则大括号也可以省略
fun( name => println(name) )
//（4）如果参数只出现一次，则参数省略且后面参数可以用_代替
fun( println(_) )
fun( println )
// 扩展：两个参数的函数
def dualFunctionOneAndTwo( fun: (Int, Int) => Int ) = {
fun( 1, 2 )
}
val add = (a: Int, b: Int) => a + b
val minus = (a: Int, b: Int) => a - b
println(dualFunctionOneAndTwo(add))
println(dualFunctionOneAndTwo(minus))
dualFunctionOneAndTwo( (a: Int, b: Int) => a + b )
dualFunctionOneAndTwo( (a, b) => a + b )
dualFunctionOneAndTwo( _ + _ )
dualFunctionOneAndTwo( _ - _ )
4.2.2 高阶函数
在Scala中，函数时一等公民，在Scala中，函数可以用作值传递，参数传递，返回值传递
案例实操：
// 函数正常声明
def f(): Int = {
println("f()")
10
}
// 函数调用和函数返回值
println(f())
// 1）函数可以作为值进行传递
val f1: ()=>Int = f
println(f1)
val f2: ()=>Int = f _
println(f2)
// 2）函数可以作为参数进行传递
def dualFunction(a: Int, b: Int, op: (Int, Int)=>Int): Int = {
op(a, b)
}
println(dualFunction(12, 46, _ + _))
println(dualFunction(12, 46, _ * _))
// 3）函数可以作为函数返回值返回
def f3(): ()=>Unit = {
def f4(): Unit ={
println("f4()")
}
f4
}
4.2.3 函数柯里化&闭包
闭包：函数式编程的标配
1）说明
闭包：如果一个函数，访问到了它的外部（局部）变量的值，那么这个函数和他所处的环境，称为闭包
函数柯里化：把一个参数列表的多个参数，变成多个参数列表。
2）案例实操
// 定义一个两数求和的函数，通用性很好，适用性较差
def add(a: Int, b: Int): Int = a + b
// 1. 考虑实际应用场景，大部分都是一个加数为4的场景
def addByFour(b: Int): Int = 4 + b
// 2. 继续考虑扩展，有一部分场景是加数固定为5
def addByFive(b: Int): Int = 5 + b
// 以上定义，适用性很好，但是通用性较差
// 3. 考虑适用性和通用性的平衡，把第一个参数单独提取出来
def addByFour1() = {
val a = 4
def addB(b: Int): Int = a + b
addB _
}
def addByA(a: Int) = {
def addB(b: Int): Int = a + b
addB _
}
println(addByFour1()(36))
println(addByA(12)(36))
// 4. 传一个参数，得到具体的函数
val addByFour2 = addByA(4)
val addByFive2 = addByA(5)
// 5. 匿名函数简写
def addByA2(a: Int): Int=>Int = {
a + _
}
// 6. 柯里化
def addCurrying(a: Int)(b: Int): Int = a + b
println(addCurrying(5)(18))
4.2.4 递归
1）说明
一个函数/方法在函数/方法体内又调用了本身，我们称之为递归调用
2）案例实操
// 求阶乘
println(factorial(5))
println(fact(5))
}
// 用循环实现
def factorial(n: Int): Int = {
var res = 1
for( i <- 1 to n ){
res *= i
}
res
}
// 递归实现
def fact(n: Int): Int = {
if( n == 0 ) return 1
n * fact(n - 1)
}
// 尾递归实现
def tailFact(n: Int): Int = {
@tailrec
def loop(acc: Int, n: Int): Int = {
if( n == 0 ) acc else loop(n * acc, n - 1)
}
loop(1, n)
注意，递归时会一致调用自己，就会导致一直压栈，压栈太多就会导致栈溢出。尾递归就会很好的解决这个问题。
尾递归是定义一个临时参数接收上面的值，这样就会解决栈溢出的问题。
@tailrec这个参数就是判断是不是尾递归。若不是尾递归，会报错。
4.2.5 抽象控制
// 1. 值调用
def f1(a: Int): Unit ={
println("f1()")
println(a)
println(a)
}
f1(10)
println("=====================")
def f2(): Int = {
println("f2()")
25
}
f1(f2())
println("=====================")
// 2. 名调用（传名参数），传递的是代码块
def f3(a: =>Int): Unit ={
println("f3()")
println(a)
println(a)
}
f3(10)
println("=====================")
f3({
println("hello")
13
})
println("=====================")
f3({f2()})
4.2.6 惰性函数
1）说明
当函数返回值被声明为lazy时，函数的执行将被推迟，直到我们首次对此取值，该函数才会执行。这种函数我们称之为惰性函数。
2）案例实操
lazy val res = sum(10, 30)
println("----------------")
println("res=" + res)
}
def sum(n1: Int, n2: Int): Int = {
println("sum被执行。。。")
return n1 + n2
}
注意：lazy不能修饰var类型的变量
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
