函数式编程
2023年12月27日大约 19 分钟约 3705 字
1）面向对象编程 解决问题，分解对象，行为，属性，然后通过对象的关系以及行为的调用来解决问题。 对象：用户 行为：登录、连接 JDBC、读取数据库 属性：用户名、密码 Scala 语言是一个完全面向对象编程语言。万物皆对象 对象的本质：对数据和行为的一个封装 2）函数式编程 解决问题时，将问题分解成一个一个的步骤，将每个步骤进行封装（函数），通过调用这些封装好的步骤，解决问题。 例如：请求->用户名、密码->连接 JDBC->读取数据库 Scala 语言是一个完全函数式编程语言。万物皆函数。 函数的本质：函数可以当做一个值进行传递 3）在 Scala 中函数式编程和面向对象编程完美融合在一起了。
函数基础
函数基本语法
函数和方法的区别
核心概念
（1）为完成某一功能的程序语句的集合，称为函数。 （2）类中的函数称之方法。
案例实操
（1）Scala 语言可以在任何的语法结构中声明任何的语法 （2）函数没有重载和重写的概念；方法可以进行重载和重写 （3）Scala 中函数可以嵌套定义
package chapter05
object Test01_FunctionAndMethod {
def main(args: Array[String]): Unit = {
// 定义函数
def sayHi(name: String): Unit = {
println("hi, " + name)
}
// 调用函数
sayHi("alice")
// 调用对象方法
Test01_FunctionAndMethod.sayHi("jack")
// 获取方法返回值
val result = Test01_FunctionAndMethod.sayHello("cary")
println(result)
}
// 定义对象的方法
def sayHi(name: String): Unit = {
println("Hi~, " + name)
}
def sayHello(name: String): String = {
println("Hello, " + name)
return "Hello"
}
}函数定义
函数定义
（1）函数 1：无参，无返回值 （2）函数 2：无参，有返回值 （3）函数 3：有参，无返回值 （4）函数 4：有参，有返回值 （5）函数 5：多参，无返回值 （6）函数 6：多参，有返回值
案例实操
package chapter05
object Test02_FunctionDefine {
def main(args: Array[String]): Unit = {
// （1）函数1：无参，无返回值
def f1(): Unit = {
println("1. 无参，无返回值")
}
f1()
println(f1())
println("=========================")
// （2）函数2：无参，有返回值
def f2(): Int = {
println("2. 无参，有返回值")
return 12
}
println(f2())
println("=========================")
// （3）函数3：有参，无返回值
def f3(name: String): Unit = {
println("3：有参，无返回值 " + name)
}
println(f3("alice"))
println("=========================")
// （4）函数4：有参，有返回值
def f4(name: String): String = {
println("4：有参，有返回值 " + name)
return "hi, " + name
}
println(f4("alice"))
println("=========================")
// （5）函数5：多参，无返回值
def f5(name1: String, name2: String): Unit = {
println("5：多参，无返回值")
println(s"${name1}和${name2}都是我的好朋友")
}
f5("alice","bob")
println("=========================")
// （6）函数6：多参，有返回值
def f6(a: Int, b: Int): Int = {
println("6：多参，有返回值")
return a + b
}
println(f6(12, 37))
}
}函数参数
（1）可变参数 （2）如果参数列表中存在多个参数，那么可变参数一般放置在最后 （3）参数默认值，一般将有默认值的参数放置在参数列表的后面 （4）带名参数
package chapter05
object Test03_FunctionParameter {
def main(args: Array[String]): Unit = {
// （1）可变参数
def f1(str: String*): Unit = {
println(str)
}
f1("alice")
f1("aaa", "bbb", "ccc")
// （2）如果参数列表中存在多个参数，那么可变参数一般放置在最后
def f2(str1: String, str2: String*): Unit = {
println("str1: " + str1 + " str2: " + str2)
}
f2("alice")
f2("aaa", "bbb", "ccc")
// （3）参数默认值，一般将有默认值的参数放置在参数列表的后面
def f3(name: String = "清华大学"): Unit = {
println("My school is " + name)
}
f3("school")
f3()
// （4）带名参数
def f4(name: String = "LiAng", age: Int): Unit = {
println(s"${age}岁的${name}在学习Scala")
}
f4("alice", 20)
f4(age = 23, name = "bob")
f4(age = 21)
}
}函数至简原则（重点）
函数至简原则：能省则省
至简原则细节
（1）return 可以省略，Scala 会使用函数体的最后一行代码作为返回值 （2）如果函数体只有一行代码，可以省略花括号 （3）返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略） （4）如果有 return，则不能省略返回值类型，必须指定 （5）如果函数明确声明 unit，那么即使函数体中使用 return 关键字也不起作用 （6）Scala 如果期望是无返回值类型，可以省略等号 （7）如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加 （8）如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略 （9）如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略
案例实操
package chapter05
object Test04_Simplify {
def main(args: Array[String]): Unit = {
def f0(name: String): String = {
return name
}
println(f0("LiAng"))
println("==========================")
// （1）return可以省略，Scala会使用函数体的最后一行代码作为返回值
def f1(name: String): String = {
name
}
println(f1("LiAng"))
println("==========================")
// （2）如果函数体只有一行代码，可以省略花括号
def f2(name: String): String = name
println(f2("LiAng"))
println("==========================")
// （3）返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略）
def f3(name: String) = name
println(f3("LiAng"))
println("==========================")
// （4）如果有return，则不能省略返回值类型，必须指定
// def f4(name: String) = {
// return name
// }
//
// println(f4("LiAng"))
println("==========================")
// （5）如果函数明确声明unit，那么即使函数体中使用return关键字也不起作用
def f5(name: String): Unit = {
return name
}
println(f5("LiAng"))
println("==========================")
// （6）Scala如果期望是无返回值类型，可以省略等号
def f6(name: String) {
println(name)
}
println(f6("LiAng"))
println("==========================")
// （7）如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加
def f7(): Unit = {
println("LiAng")
}
f7()
f7
println("==========================")
// （8）如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略
def f8: Unit = {
println("LiAng")
}
// f8()
f8
println("==========================")
// （9）如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略
def f9(name: String): Unit = {
println(name)
}
// 匿名函数，lambda表达式
(name: String) => {println(name)}
println("==========================")
}
}函数高级
匿名函数
说明
没有名字的函数就是匿名函数。 (x:Int)=>{函数体} x：表示输入参数类型；Int：表示输入参数类型；函数体：表示具体代码逻辑
案例实操
需求 1：传递的函数有一个参数 传递匿名函数至简原则： （1）参数的类型可以省略，会根据形参进行自动的推导 （2）类型省略之后，发现只有一个参数，则圆括号可以省略；其他情况：没有参数和参数超过 1 的永远不能省略圆括号。 （3）匿名函数如果只有一行，则大括号也可以省略 （4）如果参数只出现一次，则参数省略且后面参数可以用_代替
package chapter05
object Test05_Lambda {
def main(args: Array[String]): Unit = {
val fun = (name: String) => {println(name)}
fun("LiAng")
println("========================")
// 定义一个函数，以函数作为参数输入
def f(func: String => Unit): Unit = {
func("lzw")
}
f(fun)
println("========================")
// 匿名函数的简化原则
// （1）参数的类型可以省略，会根据形参进行自动的推导
f((name) => {
println(name)
})
// （2）类型省略之后，发现只有一个参数，则圆括号可以省略；其他情况：没有参数和参数超过1的永远不能省略圆括号。
f( name => {
println(name)
})
// （3）匿名函数如果只有一行，则大括号也可以省略
f( name => println(name) )
// （4）如果参数只出现一次，则参数省略且后面参数可以用_代替
f( println(_) )
// (5) 如果可以推断出，当前传入的println是一个函数体，而不是调用语句，可以直接省略下划线
f( println )
println("=========================")
// 实际示例，定义一个”二元运算“函数，只操作1和2两个数，但是具体运算通过参数传入
def dualFunctionOneAndTwo(fun: (Int, 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))
println(dualFunctionOneAndTwo((a: Int,b: Int)=> a * b))
println(dualFunctionOneAndTwo((a,b) => a+b))
println(dualFunctionOneAndTwo(_+_))
println(dualFunctionOneAndTwo((a, b) => b - a))
println(dualFunctionOneAndTwo( -_ + _))
}
}高阶函数
在 Scala 中，函数是一等公民。怎么体现的呢？ 对于一个函数我们可以：定义函数、调用函数 但是其实函数还有更高阶的用法 1）函数可以作为值进行传递 2）函数可以作为参数进行传递 3）函数可以作为函数返回值返回
package chapter05
object Test06_HighOrderFunction {
def main(args: Array[String]): Unit = {
def f(n: Int): Int = {
println("f调用")
n + 1
}
def fun(): Int = {
println("fun调用")
1
}
val result: Int = f(123)
println(result)
// 1. 函数作为值进行传递
val f1: Int=>Int = f
val f2 = f _
println(f1)
println(f1(12))
println(f2)
println(f2(35))
val f3: ()=>Int = fun
val f4 = fun _
println(f3)
println(f4)
// 2. 函数作为参数进行传递
// 定义二元计算函数
def dualEval(op: (Int, Int)=>Int, a: Int, b: Int): Int = {
op(a, b)
}
def add(a: Int, b: Int): Int = {
a + b
}
println(dualEval(add,6,8))
println(dualEval((a,b)=>a+b,8,6))
println(dualEval(_ + _, 12, 35))
// 3. 函数作为函数的返回值返回
def f5(): Int=>Unit = {
def f6(a: Int): Unit = {
println("f6调用 " + a)
}
f6 // 将函数直接返回
}
val f6 = f5()
println(f6)
println(f6(25))
//等价上面
println(f5()(25))
}
}高阶函数案例
package chapter05
object Test07_Practice_CollectionOperation {
def main(args: Array[String]): Unit = {
val arr: Array[Int] = Array(12, 45, 75, 98)
// 对数组进行处理，将操作抽象出来，处理完毕之后的结果返回一个新的数组
def arrayOperation(array: Array[Int], op: Int=>Int):Array[Int] = {
for (elem <- array) yield op(elem)
}
// 定义一个加一操作
def addOne(elem: Int): Int = {
elem + 1
}
// 调用函数
val newArray:Array[Int] = arrayOperation(arr,addOne)
println(newArray.mkString(","))
// 传入匿名函数，实现元素翻倍
val newArray2 = arrayOperation(arr, _ * 2)
println(newArray2.mkString(", "))
}
}匿名函数扩展练习
练习 1：定义一个匿名函数，并将它作为值赋给变量 fun。函数有三个参数，类型分别为 Int，String，Char，返回值类型为 Boolean。 要求调用函数 fun(0, “”, ‘0’)得到返回值为 false，其它情况均返回 true。 练习 2： 定义一个函数 func，它接收一个 Int 类型的参数，返回一个函数（记作 f1）。 它返回的函数 f1，接收一个 String 类型的参数，同样返回一个函数（记作 f2）。函数 f2 接 收一个 Char 类型的参数，返回一个 Boolean 的值。 要求调用函数 func(0) (“”) (‘0’)得到返回值为 false，其它情况均返回 true。
package chapter05
object Test08_Practice {
def main(args: Array[String]): Unit = {
// 1. 练习1
val fun = (i:Int,s:String, c:Char) => {if (i == 0 && s == "" && c == '0') false else true}
println(fun(0, "", '0'))
println(fun(0, "", '1'))
println(fun(23, "", '0'))
println(fun(0, "hello", '0'))
println("===========================")
// 2. 练习2
def func(i:Int): String=>(Char=>Boolean) = {
def f1(s:String): Char=>Boolean = {
def f2(c:Char): Boolean = {
if (i == 0 && s == "" && c == '0') false else true
}
f2
}
f1
}
println(func(0)("")('0'))
println(func(0)("")('1'))
println(func(23)("")('0'))
println(func(0)("hello")('0'))
println("-----------------------")
// 匿名函数简写
def func1(i: Int): String=>(Char=>Boolean) = {
s => c => if (i == 0 && s == "" && c == '0') false else true
}
println(func1(0)("")('0'))
println(func1(0)("")('1'))
println(func1(23)("")('0'))
println(func1(0)("hello")('0'))
println("-----------------------")
// 柯里化
def func2(i: Int)(s: String)(c: Char): Boolean = {
if (i == 0 && s == "" && c == '0') false else true
}
println(func2(0)("")('0'))
println(func2(0)("")('1'))
println(func2(23)("")('0'))
println(func2(0)("hello")('0'))
}
}函数柯里化&闭包
闭包：函数式编程的标配
说明
闭包：如果一个函数，访问到了它的外部（局部）变量的值，那么这个函数和他所处的 环境，称为闭包。 函数柯里化：把一个参数列表的多个参数，变成多个参数列表。
案例实操
package chapter05
object Test09_ClosureAndCurrying {
def main(args: Array[String]): Unit = {
def add(a: Int, b: Int): Int = {
a + b
}
// 1. 考虑固定一个加数的场景
def addByFour(b: Int): Int = {
4 + b
}
// 2. 扩展固定加数改变的情况
def addByFive(b: Int): Int = {
5 + b
}
// 3. 将固定加数作为另一个参数传入，但是是作为”第一层参数“传入
def addByFour1(): Int=>Int = {
val a = 4
def addB(b: Int):Int = {
a + b
}
addB
}
def addByA(a: Int): Int=>Int = {
def addB(b: Int):Int = {
a + b
}
addB
}
println(addByA(35)(24))
val addByFour2 = addByA(4)
val addByFive2 = addByA(5)
println(addByFour2(13))
println(addByFive2(25))
// 4. lambda表达式简写
def addByA1(a: Int): Int=>Int= {
(b: Int) => {
a + b
}
}
def addByA2(a: Int): Int=>Int= {
b => a + b
}
def addByA3(a: Int): Int=>Int= a + _
val addByFour3 = addByA3(4)
val addByFive3 = addByA3(5)
println(addByFour3(13))
println(addByFive3(25))
// 5. 柯里化
def addCurrying(a: Int)(b: Int): Int = {
a + b
}
println(addCurrying(35)(24))
}
}递归
说明
一个函数/方法在函数/方法体内又调用了本身，我们称之为递归调用。
案例实操
package chapter05
import scala.annotation.tailrec
object Test10_Recursion {
def main(args: Array[String]): Unit = {
println(fact(5))
println(tailFact(5))
}
// 递归实现计算阶乘
def fact(n: Int): Int = {
if(n == 0) return 1
fact(n - 1) * n
}
// 尾递归实现
def tailFact(n: Int): Int = {
@tailrec
def loop(n: Int, currRes: Int): Int = {
if(n == 0) return currRes
loop(n-1, currRes * n)
}
loop(n,1)
}
}控制抽象
1）值调用：把计算后的值传递过去
package chapter05
object Test11_ControlAbstraction {
def main(args: Array[String]): Unit = {
// 1. 传值参数
def f0(a: Int): Unit = {
println("a: " + a)
println("a: " + a)
}
f0(23)
def f1(): Int = {
println("f1调用")
12
}
f0(f1())
println("========================")
}
}2）名调用：把代码传递过去
// 2. 传名参数，传递的不再是具体的值，而是代码块
def f2(a: =>Int): Unit = {
println("a: " + a)
println("a: " + a)
}
f2(23)
f2(f1())
f2({
println("这是一个代码块")
29
})注意：Java 只有值调用；Scala 既有值调用，又有名调用。 3）自定义一个 While 循环
package chapter05
import java.util.concurrent.locks.Condition
object Test12_MyWhile {
def main(args: Array[String]): Unit = {
var n = 10;
// 1. 常规的while循环
while (n >= 1){
println(n)
n -= 1
}
// 2. 用闭包实现一个函数，将代码块作为参数传入，递归调用
def myWhile(condition: =>Boolean): (=>Unit)=>Unit = {
// 内层函数需要递归调用，参数就是循环体
def doLoop(op: =>Unit): Unit = {
if(condition){
op
myWhile(condition)(op)
}
}
doLoop _
}
println("=================")
n = 10
myWhile(n >= 1){
println(n)
n -= 1
}
// 3. 用匿名函数实现
def myWhile2(condition: =>Boolean): (=>Unit)=>Unit = {
// 内层函数需要递归调用，参数就是循环体
op => {
if(condition){
op
myWhile2(condition)(op)
}
}
}
println("=================")
n = 10
myWhile2(n >= 1){
println(n)
n -= 1
}
// 3. 用柯里化实现
def myWhile3(condition: =>Boolean)(op: =>Unit):Unit = {
if (condition){
op
myWhile3(condition)(op)
}
}
println("=================")
n = 10
myWhile3(n >= 1){
println(n)
n -= 1
}
}
}惰性加载
说明
当函数返回值被声明为 lazy 时，函数的执行将被推迟，直到我们首次对此取值，该函数才会执行。这种函数我们称之为惰性函数。
案例实操
package chapter05
object Test13_Lazy {
def main(args: Array[String]): Unit = {
lazy val result: Int = sum(13, 47)
println("1. 函数调用")
println("2. result = " + result)
println("4. result = " + result)
}
def sum(a: Int, b: Int): Int = {
println("3. sum调用")
a + b
}
}注意：lazy 不能修饰 var 类型的变量