文章目录

5. 函数式编程5.1 函数基础5.1.1 函数基本语法5.1.2 函数和方法的区别5.1.3 函数定义5.1.4 函数参数5.1.5 函数至简原则（重点） 5.2 函数高级5.2.1 高阶函数5.2.2 匿名函数5.2.3 高阶函数案例(集合详细讲)5.2.4 函数柯里化&闭包5.2.5 递归5.2.6 控制抽象5.2.7 惰性函数

5. 函数式编程

5.1 函数基础

5.1.1 函数基本语法

1）基本语法

2）案例实操

object TestFunction { def main(args: Array[String]): Unit = { def fun(arg:String):Unit={ println(arg) } fun("你好") } }

5.1.2 函数和方法的区别

1）核心概念

（1）完成某个特殊功能的代码块，称为函数。

（2）定义在类下的函数，叫方法

（3）函数和方法定义的位置不一样

2）案例实操

（1）Scala语言可以在任何的语法结构中声明任何的语法

（2）函数没有重载和重写的概念；方法可以进行重载和重写；重载对调用者可以屏蔽掉因为方法参数不同而产生的差异

（3）Scala中函数可以嵌套定义

object TestFunction { // (2)方法可以进行重载和重写，程序可以执行 def main(): Unit = { } def main(args: Array[String]): Unit = { // （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("函数可以嵌套定义") } } } }

5.1.3 函数定义

object TestFunctionDeclare { def main(args: Array[String]): Unit = { // 函数1：无参，无返回值 def test1(): Unit ={ println("无参，无返回值") } test1() // 函数2：无参，有返回值 def test2():String={ return "无参，有返回值" } println(test2()) // 函数3：有参，无返回值 def test3(s:String):Unit={ println(s) } test3("jinlian") // 函数4：有参，有返回值 def test4(s:String):String={ return s+"有参，有返回值" } println(test4("hello ")) // 函数5：多参，无返回值 def test5(name:String, age:Int):Unit={ println(s"$name, $age") } test5("dalang",40) } }

5.1.4 函数参数

1）案例实操

object TestFunction { def main(args: Array[String]): Unit = { // （1）可变参数 def test( s : String* ): Unit = { println(s) } // 有输入参数：输出 Array test("Hello", "Scala") // 无输入参数：输出List() test() // (2)如果参数列表中存在多个参数，那么可变参数一般放置在最后，且只能有一个可变参数 def test2( name : String, s: String* ): Unit = { println(name + "," + s) } test2("jinlian", "dalang") // (3)参数默认值 def test3( name : String, age : Int = 30 ): Unit = { println(s"$name, $age") } // 如果参数传递了值，那么会覆盖默认值 test3("jinlian", 20) // 如果参数有默认值，在调用的时候，可以省略这个参数 test3("dalang") // 一般情况下，将有默认值的参数放置在参数列表的后面 def test4( sex : String = "男", name : String ): Unit = { println(s"$name, $sex") } // Scala函数中参数传递是，从左到右 //test4("wusong") //需要使用带名参数进行赋值 //（4）带名参数 test4(name="ximenqing") } }

5.1.5 函数至简原则（重点）

object TestFunction { def main(args: Array[String]): Unit = { // （0）函数标准写法 def f( s : String ): String = { return s + " jinlian" } println(f("Hello")) // 至简原则:能省则省 //（1） return可以省略,Scala会使用函数体的最后一行代码作为返回值 def f1( s : String ): String = { s + " jinlian" } println(f1("Hello")) //（2）如果函数体只有一行代码，可以省略花括号 def f2(s:String):String = s + " jinlian" //（3）返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略） def f3( s : String ) = s + " jinlian" println(f3("Hello3")) //（4）如果有return，则不能省略返回值类型，必须指定。 def f4() :String = { return "ximenqing4" } println(f4()) //（5）如果函数明确声明unit，那么即使函数体中使用return关键字也不起作用 def f5(): Unit = { return "dalang5" } println(f5()) //（6）Scala如果期望是无返回值类型,可以省略等号 // 将无返回值的函数称之为过程 def f6() { "dalang6" } println(f6()) //（7）如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加 def f7() = "dalang7" println(f7()) println(f7) //（8）如果函数没有参数列表，那么小括号可以省略,调用时小括号必须省略 def f8 = "dalang" //println(f8()) println(f8) //（9）如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略 //函数类型 ff：（参数列表声明）=>返回值 def f9(f:(String)=>Unit): Unit ={ f("zmzdmx") } def f10(s:String): Unit ={ println(s) } f9(f10) //匿名函数 通过Lambda表达式实现 参数->函数体 f9((s:String)=>{println(s)}) // *参数的类型可以省略，会根据形参进行自动的推导 f9((s)=>{println(s)}) // *类型省略之后，发现只有一个参数，则圆括号可以省略；其他情况：没有参数和参数超过1的永远不能省略圆括号。 f9(s=>{println(s)}) // *匿名函数如果只有一行，则大括号也可以省略 f9(s=>println(s)) // *如果参数只出现一次，则参数省略且后面参数可以用_代替 f9(println(_)) } }

lambda表达式（参数列表->函数体）

package nj.zb.kb09.test; public interface PanDuan { public Integer pd(String str); } package nj.zb.kb09.test; import nj.zb.kb09.inter.OperationInterface; public class test { public static void main(String[] args) { PanDuan panDuan=(String str)->{ if (str.contains("A")){ return 1; }else if (str.contains("B")){ return 2; }else { return 0; } }; System.out.println(panDuan.pd("Abc")); } }

5.2 函数高级

5.2.1 高阶函数

对于一个函数我们可以：定义函数、调用函数

object TestFunction { def main(args: Array[String]): Unit = { // 调用函数 foo() } // 定义函数 def foo():Unit = { println("foo...") } }

1）函数可以作为值进行传递

object TestFunction { def main(args: Array[String]): Unit = { //（1）调用foo函数，把返回值给变量f //val f = foo() val f = foo println(f) //（2）在被调用函数foo后面加上 _，相当于把函数foo当成一个整体，传递给变量f1 //语法：在函数名称的后面 + 空格 加下划线（_） val f1 = foo _ //这个时候，f1就是一个函数，如果想要运行f1函数的话，必须得加（） foo() f1() //（3）如果明确变量类型，那么不使用下划线也可以将函数作为整体传递给变量 var f2:()=>Int = foo } def foo():Int = { println("foo...") 1 } }

注意

var ff=foo //将函数执行结果赋值给ff var ff=foo _ //将函数本身作为值赋给ff var ff:()=>Unit =foo //将函数本身作为值赋给ff,如果明确了变量类型，那么空格和下划线可以省略

2）函数可以作为参数进行传递（大多数情况都是通过匿名函数的形式）

def main(args: Array[String]): Unit = { // （1）定义一个函数，函数参数还是一个函数签名；f表示函数名称;(Int,Int)表示输入两个Int参数；Int表示函数返回值 def f1(f: (Int, Int) => Int): Int = { f(2, 4) } // （2）定义一个函数，参数和返回值类型和f1的输入参数一致 def add(a: Int, b: Int): Int = a + b // （3）将add函数作为参数传递给f1函数，如果能够推断出来不是调用，_可以省略 println(f1(add)) println(f1(add _)) //可以传递匿名函数 //方法二 println(f1((a:Int,b:Int)=>{a+b})) //传入一个函数进行计算 println(f1((a,b)=>a+b)) //自动推导变量类型 println(f1(_+_) //a b 只出现过一次，可以用下划线代替 }

3）函数可以作为函数返回值返回—函数嵌套

def main(args: Array[String]): Unit = { def f1():()=>Unit={ def f2(): Unit ={ println("f2 is used") } f2 _ //将f2作为返回值返回给f1 } val f = f1() // 因为f1函数的返回值依然为函数，所以可以变量f可以作为函数继续调用 f() // 上面的代码可以简化为 f1()() }

5.2.2 匿名函数

1）说明

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

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

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

2）案例实操

​ 需求1：传递的函数有一个参数

传递匿名函数至简原则：

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

（2）类型省略之后，发现只有一个参数，则圆括号可以省略；其他情况：没有参数和参数超过1的永远不能省略圆括号。

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

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

def main(args: Array[String]): Unit = { // （1）定义一个函数：参数包含数据和逻辑函数 def operation(arr: Array[Int], op: Int => Int) = { for (elem <- arr) yield op(elem) } // （2）定义逻辑函数 def op(ele: Int): Int = { ele + 1 } // （3）标准函数调用 val arr = operation(Array(1, 2, 3, 4), op) println(arr.mkString(",")) // （4）采用匿名函数 val arr1 = operation(Array(1, 2, 3, 4), (ele: Int) => { ele + 1 }) println(arr1.mkString(",")) // （4.1）参数的类型可以省略，会根据形参进行自动的推导; val arr2 = operation(Array(1, 2, 3, 4), (ele) => { ele + 1 }) println(arr2.mkString(",")) // （4.2）类型省略之后，发现只有一个参数，则圆括号可以省略；其他情况：没有参数和参数超过1的永远不能省略圆括号。 val arr3 = operation(Array(1, 2, 3, 4), ele => { ele + 1 }) println(arr3.mkString(",")) // (4.3) 匿名函数如果只有一行，则大括号也可以省略 val arr4 = operation(Array(1, 2, 3, 4), ele => ele + 1) println(arr4.mkString(",")) //（4.4）如果参数只出现一次，则参数省略且后面参数可以用_代替 val arr5 = operation(Array(1, 2, 3, 4), _ + 1) println(arr5.mkString(",")) } }

需求2：传递的函数有两个参数

object TestFunction { def main(args: Array[String]): Unit = { def calculator(a: Int, b: Int, op: (Int, Int) => Int): Int = { op(a, b) } // （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, _ + _)) } }

小练习

编写程序实现：f(10)(20)(_*_)输出结果为200

object TestFunction { def main(args: Array[String]): Unit = { def f(x:Int)={ def f1(y:Int) ={ def f2(fun:(Int,Int)=>Int) ={ fun(x,y) } f2 _ } f1 _ } println(f(10)(20)(_*_)) } }

5.2.3 高阶函数案例(集合详细讲)

需求：模拟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) = { var init: Int = arr(0) for (elem <- 1 until arr.length) { init = op(init, elem) } init } //val arr2 = reduce(Array(1, 2, 3, 4), (x, y) => x * y) val arr2 = reduce(Array(1, 2, 3, 4), _ * _) println(arr2) } }

5.2.4 函数柯里化&闭包

函数链式调用，通过参数传递数据，在执行的过程中，函数始终占据栈内存，容易导致内存溢出

闭包：函数式编程的标配

1）说明

闭包：如果一个函数，访问到了它的外部（局部）变量的值，那么这个函数和他所处的环境，称为闭包

函数柯里化：把一个参数列表的多个参数，变成多个参数列表。

2）案例实操

​ （1）闭包

object TestFunction { def main(args: Array[String]): Unit = { def f1()={ var a:Int = 10 def f2(b:Int)={ a + b } f2 _ } // 在调用时，f1函数执行完毕后，局部变量a应该随着栈空间释放掉 val f = f1() // 但是在此处，变量a其实并没有释放，而是包含在了f2函数的内部，形成了闭合的效果 //如果闭包存在，那么编译器会生成包含$anonfun$的字节码文件 //闭包= 外层的局部变量 + 内层函数 println(f(3)) println(f1()(3)) // 函数柯里化，其实就是将复杂的参数逻辑变得简单化,函数柯里化一定存在闭包 //将一个函数的一个参数列表中的多个参数，拆分为多个参数列表 //简化闭包代码的编写 def f3()(b:Int)={ a + b } println(f3()(3)) } }

5.2.5 递归

柯理化是对函数嵌套的简单化，但是这里只有一层函数体，如果每层函数完成的业务逻辑不一样，一个函数如何处理？？？？

1）说明

​ 一个函数/方法在函数/方法体内又调用了本身，我们称之为递归调用

2）案例实操

object TestFunction { def main(args: Array[String]): Unit = { // 阶乘 // 递归算法 // 1) 方法调用自身 // 2) 方法必须要有跳出的逻辑 // 3) 方法调用自身时，传递的参数应该有规律 // 4) scala中的递归必须声明函数返回值类型 println(test(5)) } def test(i : Int) : Int = { if (i == 1) { 1 } else { i * test(I - 1) } } }

5.2.6 控制抽象

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没有小括号了 代码块： =>返回值类型 /*这里 a就变成了{ println("f...") 10 }*/ println(a) println(a) } } 输出结果： f... 10 f... 10

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

3）案例实操

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循环

柯理化好处1：讲一个参数列表的多个参数，拆分为多个参数列表，这样参数所表示的含义，清晰、明确

object TestFunction { def main(args: Array[String]): Unit = { //使用柯理化 实现 mywhile（循环条件）（循环体） var i:Int = 1 myWhile(i <= 10){ println(i) i +=1 } } def myWhile(condition: =>Boolean)(op: =>Unit):Unit={ if (condition){ op myWhile(condition)(op) } } }

柯理化简化函数代码

package demo object TestFunction { def main(args: Array[String]): Unit = { //使用闭包的形式，实现mywhile //外层函数的参数表示循环条件 def mywhile(con: =>Boolean):( =>Unit)=>Unit={ //内层函数参数表示循环体 def ff(op: =>Unit): Unit ={ if (con){ op mywhile(con)(op) } } ff } var n=10 mywhile(n>=1){ println(n) n-=1 } } }

5.2.7 惰性函数

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类型的变量