第 5 章 Scala函数式编程

最新推荐文章于 2024-06-16 17:46:30 发布

怕被各位卷死

最新推荐文章于 2024-06-16 17:46:30 发布

阅读量85

点赞数

分类专栏： Scala（新版）学习笔记文章标签： scala 开发语言后端 java 大数据 Powered by 金山文档

本文链接：https://blog.csdn.net/weixin_45077811/article/details/128872120

版权

Scala（新版）学习笔记专栏收录该内容

12 篇文章 1 订阅

订阅专栏

1）面向对象编程

解决问题，分解对象，行为，属性，然后通过对象的关系以及行为的调用来解决问题。

对象：用户

行为：登录、连接 JDBC、读取数据库

属性：用户名、密码

Scala 语言是一个完全面向对象编程语言。万物皆对象

对象的本质：对数据和行为的一个封装

2）函数式编程

解决问题时，将问题分解成一个一个的步骤，将每个步骤进行封装（函数），通过调用这些封装好的步骤，解决问题。

例如：请求->用户名、密码->连接 JDBC->读取数据库

Scala 语言是一个完全函数式编程语言。万物皆函数。

函数的本质：函数可以当做一个值进行传递

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

5.1 函数基础

5.1.1 函数基本语法

- 基本语法

2）案例实操

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

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

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

5.1.3 函数定义

1）函数定义

（1）函数 1：无参，无返回值

（2）函数 2：无参，有返回值

（3）函数 3：有参，无返回值

（4）函数 4：有参，有返回值

（5）函数 5：多参，无返回值

（6）函数 6：多参，有返回值

2）案例实操

package com.learn.day05

/**
 * @author Lucaslee
 * @create 2023-02-02 15:56
 */
object Test02_FunctionDefine {
  def main(args: Array[String]): Unit = {
    //没有参数也没有返回值
    def f1(): Unit = {
      println("没有参数也没有返回值")
    }
//    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))
  }

}

5.1.4 函数参数

1）案例实操

（1）可变参数

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

（3）参数默认值，一般将有默认值的参数放置在参数列表的后面

（4）带名参数

package com.learn.day05

/**
 * @author Lucaslee
 * @create 2023-02-02 16:07
 */
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 = "atguigu"): Unit = {
      println("My school is " + name)
    }

    f3("school")
    f3()

    //  （4）带名参数
    def f4(name: String = "atguigu", age: Int): Unit = {
      println(s"${age}岁的${name}在尚硅谷学习")
    }

    f4("alice", 20)
    //可以乱序传参，只要指定参数名就好
    f4(age = 23, name = "bob")
    f4(age = 21)
  }
}

5.1.5 函数至简原则（重点）

函数至简原则：能省则省

1）至简原则细节

（1）return 可以省略，Scala 会使用函数体的最后一行代码作为返回值

（2）如果函数体只有一行代码，可以省略花括号

（3）返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略）

（4）如果有 return，则不能省略返回值类型，必须指定

（5）如果函数明确声明 unit，那么即使函数体中使用 return 关键字也不起作用

（6）Scala 如果期望是无返回值类型，可以省略等号

（7）如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加

（8）如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略

（9）如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略

2）案例实操

package com.learn.day05

/**
 * @author Lucaslee
 * @create 2023-02-02 16:19
 */
//函数至简原则
object Test04_Simplify {
  def main(args: Array[String]): Unit = {
    // （0）函数标准写法
    def f0(name: String): String = {
      return name
    }
    println(f0("atguigu"))
    println("==========================")

    //  （1）return 可以省略，Scala 会使用函数体的最后一行代码作为返回值
    def f1(name: String): String = {
      name
    }
    println(f1("atguigu"))

    println("==========================")
    //  （2）如果函数体只有一行代码，可以省略花括号
    def f2(name: String): String = name
    println(f2("atguigu"))

    println("==========================")
    //  （3）返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略）
    def f3(name: String) = name
    println(f3("atguigu"))

    println("==========================")
    //  （4）如果有 return，则不能省略返回值类型，必须指定
    //    def f4(name: String) = {
    //      return name
    //    }
    //
    //    println(f4("atguigu"))

    println("==========================")
    //  （5）如果函数明确声明 unit，那么即使函数体中使用 return 关键字也不起作用
    def f5(name: String): Unit = {
      return name
    }

    println(f5("atguigu"))
    //  （6）Scala 如果期望是无返回值类型，可以省略等号
    def f6(name: String) {
      println(name)
    }

    println(f6("atguigu"))

    println("==========================")
    //  （7）如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加
    def f7(): Unit = {
      println("atguigu")
    }

    f7()
    f7

    println("==========================")
    //  （8）如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略
    def f8: Unit = {
      println("atguigu")
    }

    //    f8()
    f8

    println("==========================")
    //  （9）如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略
    //正常情况下是这样
    def f9(name: String): Unit = {
      println(name)
    }
    
    //省略def后，变成这样
    // 匿名函数，lambda表达式
    (name: String) => { println(name) }

      println("==========================")
  }

}

lambda表达式的简化：

object Test05_Lambda {
  def main(args: Array[String]): Unit = {
    val fun = (name: String) => {
      println(name)
    }
    fun("atguigu")

    println("========================")

    // 定义一个函数，以函数作为参数输入
    def f(func: String => Unit): Unit = {
      func("atguigu")
    }

    f(fun)
    f((name: String) => {
      println(name)
    })

    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: Int, b: Int) => a - b))

    println(dualFunctionOneAndTwo((a, b) => a + b))
    println(dualFunctionOneAndTwo( _ + _))
    println(dualFunctionOneAndTwo( _ - _))

    println(dualFunctionOneAndTwo((a, b) => b - a))
    println(dualFunctionOneAndTwo( -_ + _))
  }
}

5.2 函数高级

5.2.1 高阶函数

在 Scala 中，函数是一等公民。怎么体现的呢？

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

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

2）函数可以作为参数进行传递

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

}

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

object Test05_Lambda {
  def main(args: Array[String]): Unit = {
    def f1() = {
      def f2() = {
      }

      f2 _
    }

    val f = f1()
    // 因为 f1 函数的返回值依然为函数，所以可以变量 f 可以作为函数继续调用
    f()
    // 上面的代码可以简化为
    f1()()
  }

}

5.2.2 匿名函数

1）说明

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

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

x：表示输入参数类型；

Int：表示输入参数类型；

函数体：表示具体代码逻辑

2）案例实操

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

传递匿名函数至简原则：

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

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

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

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

package com.learn.day05

/**
 * @author Lucaslee
 * @create 2023-02-02 16:45
 */
object Test05_Lambda {
  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, _ + _))
  }
}

扩展练习

练习 1：定义一个匿名函数，并将它作为值赋给变量 fun。函数有三个参数，类型分别为 Int，String，Char，返回值类型为 Boolean。

要求调用函数 fun(0, “”, ‘0’)得到返回值为 false，其它情况均返回 true。

 // 1. 练习1
   //普通写法
   def f(num: Int,str: String,cha: Char): Boolean ={
     if(num == 0 && str == "" && cha == '0'){false}
     else {true}
   }
    //匿名函数写法
    val fun = (num: Int,str: String,cha: Char) => { if(num == 0 && str == "" && cha == '0')false else true }

    println(fun(0, "", '0'))
    println(fun(0, "", '1'))
    println(fun(23, "", '0'))
    println(fun(0, "hello", '0'))
    
    
    输出：
    false
    true
    true
    true

练习 2：定义一个函数 func，它接收一个 Int 类型的参数，返回一个函数（记作 f1）。

它返回的函数 f1，接收一个 String 类型的参数，同样返回一个函数（记作 f2）。函数 f2 接收一个 Char 类型的参数，返回一个 Boolean 的值。

要求调用函数 func(0) (“”) (‘0’)得到返回值为 false，其它情况均返回 true。

    // 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'))

    // 匿名函数简写
    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'))

    // 柯里化
    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'))

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

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

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 没有小括号了
    println(a)
    println(a)
  }
}
输出结果：
f...
10
f...
10

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

3）案例实操1

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

4）案例实操2

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  //传名参数 ** 注意：Java 只有值调用；Scala 既有值调用，又有名调用。**
        myWhile3(condition)(op)
      }
    }

    println("=================")
    n = 10
    myWhile3(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 类型的变量