Scala（第五章 函数式编程）

1）面向对象编程

1、 解决问题，分解对象，行为，属性，然后通过对象的关系以及行为的调用来解决问题。
对象：用户
行为：登录、连接JDBC、读取数据库
属性：用户名、密码
2、Scala语言是一个完全面向对象编程语言，万物皆对象。
3、对象的本质：对数据和行为的一个封装

2）函数式编程

1、解决问题时，将问题分解成一个一个的步骤，将每个步骤进行封装（函数），通过调用这些封装好的步骤，解决问题。
例如：请求 -> 用户名、密码 -> 连接JDBC -> 读取数据库
2、Scala语言是一个完全函数式编程语言。万物皆函数。
3、函数的本质：函数可以当作一个值进行转递

3）在Scala中函数式编程和面向对象编程完美融合在一起了。

5.1 函数基础

5.1.1 函数基本语法

1）基本语法

2）案例实操

需求：定义一个函数，实现将传入的名称打印出来。

object TestFunction {
 def main(args: Array[String]): Unit = {
	 // （1）函数定义
	 def f(arg: String): Unit = {
	  println(arg)
	 }
	 // （2）函数调用
	 // 函数名（参数）
	 f("hello world")
 }
}

   
   

   
   
1
2
3
4
5
6
7
8
9
10
11

5.1.2 函数和方法的区别

1）核心概念

1、为完成某一功能的程序语句的集合，称为函数。
2、类中的函数称之为方法。

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("函数可以嵌套定义")
       }
      }
   }
}

   
   

   
   

    
    
   
   
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

5.1.3 函数定义

1）函数定义

（1）函数 1：无参，无返回值
（2）函数 2：无参，有返回值
（3）函数 3：有参，无返回值
（4）函数 4：有参，有返回值
（5）函数 5：多参，无返回值
（6）函数 6：多参，有返回值

2）案例实操

package com.atguigu.chapter05
 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)
  }
}

   
   

   
   

    
    
   
   
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

5.1.4 函数参数

1）案例实操

（1）可变参数
（2）如果参数列表中存在多个参数，那么可变参数一般放置在最后
（3）参数默认值，一般将有默认值的参数放置在参数列表的后面
（4）带名参数

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")
 }
}

   
   

   
   

    
    
   
   
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

5.1.5 函数至简原则（重点）

函数至简原则：能省则省

1）至简原则细节

（1）return 可以省略，Scala 会使用函数体的最后一行代码作为返回值
（2）如果函数体只有一行代码，可以省略花括号
（3）返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略）
（4）如果有 return，则不能省略返回值类型，必须指定
（5）如果函数明确声明 unit，那么即使函数体中使用 return 关键字也不起作用
（6）Scala 如果期望是无返回值类型，可以省略等号
（7）如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加
（8）如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略
（9）如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略

2）案例实操

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）可以省略
 def f9 = (x:String)=>{println("wusong")}
 def f10(f:String=>Unit) = {
 f("")
 }
 f10(f9)
 println(f10((x:String)=>{println("wusong")}))
 }
}

   
   

   
   

    
    
   
   
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

5.2 函数高级

5.2.1 高阶函数

1、在Scala中，函数是一等公民。怎么体现的呢?
2、对于一个函数我们可以：定义函数、调用函数

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

   
   

   
   
1
2
3
4
5
6
7
8
9
10

3、但是其实函数还有更高阶的用法

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 _
 foo()
 f1()
//（3）如果明确变量类型，那么不使用下划线也可以将函数作为整体传递给变量
var f2:()=>Int = foo 
 }
 def foo():Int = {
   println("foo...")
 1
 }
}

   
   

   
   

    
    
   
   
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

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 _))
//可以传递匿名函数
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15

3）函数可以作为函数返回值返回

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

 
 

 
 
1
2
3
4
5
6
7
8
9
10
11
12

5.2.2 匿名函数

1）说明

没有名字的函数就是匿名函数。
(x: Int) => {函数体}
x: 表示输入参数类型;Int: 表示输入参数类型；函数体：表示具体代码逻辑

 
 

 
 
1
2
3

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(","))
 }
}

 
 

 
 

  
  
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

需求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, _ + _))
 }
}

 
 

 
 

  
  
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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)
 }
}

 
 

 
 

  
  
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

5.2.4 函数柯里化&闭包

闭包：函数式编程的标配

1）说明

1、闭包：如果一个函数，访问到了它的外部（局部）变量的值，那么这个函数和他所处的环境，称为闭包
2、函数柯里化：把一个参数列表的多个参数，变成多个参数列表

2）案例实操

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 函数的内部，形成了闭合的效果
 println(f(3))

println(f1()(3))
// 函数柯里化，其实就是将复杂的参数逻辑变得简单化,函数柯里化一定存在闭包
def f3()(b:Int)={
a + b
}
println(f3()(3))
}
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22

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)
 }
 }
}

 
 

 
 

  
  
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

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)
 }
}

 
 

 
 
1
2
3
4
5
6
7
8
9
10
11
12
13

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 

 
 

 
 

  
  
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

注意：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)
 }
}

 
 

 
 

  
  
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

自定义一个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
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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
}

 
 

 
 
1
2
3
4
5
6
7
8
9

输出结果：

sum被执行。。。。
res = 40

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

下一章（第六章） 面向对象