• Scala入门到精通(尚硅谷学习笔记)章节七——函数式编程

    scala支持两种编程范例：面向对象编程（ OOP ）和函数编程（ FP ）。
    函数式编程在解决问题时，将问题分解成一个一个的步骤，将每个步骤进行封装(函数)，通过调用这些封装好的步骤，解决问题。
    在 Scala 当中，函数既可以作为函数的参数使用，也可以将函数赋值给一个变量. ，函数的创建不用依赖于类或者对象。

    函数基础

    在这里插入图片描述
    如果不写等于号和方法主体，那么方法会被隐式声明为抽象(abstract)，包含它的类型于是也是一个抽象类型。

    函数和方法的区别

    1. 函数在scala语言中，是函数编程的 “头等公民”
    2. 方法是 scala 面向对象中的概念，主要定义在类，特质，抽象类中
    3. 函数是一个对象，方法本质就是类中的一个普通的方法
    4. 函数可以作为参数进行传递,可以作为返回值返回,但是方法不行
    5. 方法可以通过一定的语法转成函数
      参考博文：https://blog.csdn.net/mswuxianshen/article/details/84
      def main(args: Array[String]): Unit = {

    //定义函数
    def sayHi(name:String):Unit = {
      println("hi,"+name)
    }

    //调用函数
    sayHi(name ="alice")

	//调用对象方法
	this.sayHi(NAME="Bob")
  }
  //定义对象的方法
  def sayHi(name:String):Unit = {
    println("Hi,"+name)
  }

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

    返回值

    (1)函数1:无参，无返回值

        def f1():Unit ={
      println("1.无参，无返回值")
    }
    //调用
    f1()

    • 1
    • 2
    • 3
    • 4
    • 5

    (2)函数2:无参，有返回值

        def f2():Int ={
      println("1.无参，有返回值")
      return 12
    }
    //调用
    println(f2())//12

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    (3)函数3:有参，无返回值

        def f3(name:String):Unit ={
      println("3.有参，无返回值"+name)//输出：有参，无返回值alice
    }
    println(f3(name="alice" ))//输出：()

    • 1
    • 2
    • 3
    • 4

    (4)函数4:有参，有返回值

        def f3(name:String):String ={
      println("3.有参，无返回值"+name)//输出：有参，无返回值alice
      return "hi,"+name
    }
    println(f3(name="alice" ))//输出：hi,alice

    • 1
    • 2
    • 3
    • 4
    • 5

    可变参数

    Scala 允许指明函数的最后一个参数可以重复，即我们不需要指定函数参数的个数，可以向函数传入可变长度参数列表。
    Scala 通过在参数的类型之后放一个星号来设置可变参数(可重复的参数)。

        def f1(str:String*):Unit ={
      println(str)
    }
    f1(str="alice")//WrappedArray(alice)
    f1("aaa","bbb","ccc")//WrappedArray(aaa, bbb, ccc)

    • 1
    • 2
    • 3
    • 4
    • 5

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

         def f1(str1:String,str2:String*):Unit ={
      println("str1 "+str1+"str2 "+str2)
    }
    f1(str1="alice")//str1 alicestr2 WrappedArray()
    f1("aaa","bbb","ccc")//str1 aaastr2 WrappedArray(bbb, ccc)

    • 1
    • 2
    • 3
    • 4
    • 5

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

        def f1(str:String="Heria"):Unit ={
      println("My name is  "+str)
    }
    f1("Java")//My name is  Java
    f1()//My name is  Heria

    • 1
    • 2
    • 3
    • 4
    • 5

    函数至简原则：能省则省

    现有原始长度函数

        def f0(name:String):String ={
      return name
    }
    println(f0("Heria"))

    • 1
    • 2
    • 3
    • 4

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

        def f1(name:String):String ={name}
    println(f1("Heria"))

    • 1
    • 2

    二、如果函数体只有一行代码，可以省略花括号

        def f2(name:String):String =name
    println(f2("Heria"))

    • 1
    • 2

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

        def f3(name:String) =name
    println(f3("Heria"))

    • 1
    • 2

    四、如果有return，则不能省略返回值类型，必须指定
    五、如果函数明确声明unit，那么即使函数体中使用return关键字也不起作用
    六、Scala如果期望是无返回值类型，可以省略等号

        def f6(name:String){
      println("Heria")
    }

    • 1
    • 2
    • 3

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

        def f7():Unit={
      println("Heria")
    }
    f7

    • 1
    • 2
    • 3
    • 4

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

        def f8:Unit={
      println("Heria")
    }
    f8

    • 1
    • 2
    • 3
    • 4

    九、如果不关心名称，只关心逻辑处理，那么西数名(def)可以省略

    //匿名函数，lambda表达式
(name:String)=>{println(name)}

    • 1
    • 2

    匿名函数

    Scala支持一级函数，函数可以用函数文字语法表达

    //匿名函数，lambda表达式
val fun = (name:String)=>{println(name)}
//val stringToUnit: String => Unit = (name:String) => {println(name)}
//以String作为参数，Unit作为返回值的函数
fun("Heria")

    • 1
    • 2
    • 3
    • 4
    • 5

    匿名函数的主要作用是作为参数参与函数的运行

    val fun = (name:String)=>{println(name)}
def f(func:String=>Unit):Unit={
	func("Heria")
}
f(fun)

    • 1
    • 2
    • 3
    • 4
    • 5

    为什么这个函数可以直接打印？因为f函数调用了func这个作为参数的函数，而我们在调用f函数时，是将fun函数作为参数传入的。fun函数需要传入String类型的参数，func("Heria")将Heria作为参数传入。
    f()这种类型的函数的目的是为了针对固定的数据，传入不同的函数对数据进行操作
    匿名函数的简化原则

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

    • 1

    一、参数的类型可以省略,会根据形参进行自动的推导

    f((name)=>{
    println(name)
  })

    • 1
    • 2
    • 3

    二、类型省略之后，发现只有一个参数，则圆括号可以省略;没有参数和参数超过一的永远不能省略括号。

    f(name=>{
    println(name)
  })

    • 1
    • 2
    • 3

    三、匿名函数如果只有一行,则大括号也可以省略

    f(name=>
    println(name))

    • 1
    • 2

    四、如果参数只出现一次,则参数省略且后面参数可以用_代替

    f(println(_))

    • 1

    五、如果可以推断出，当前传入的println是一个函数体，而不是调用语句，可以直接省略下划线

    f(println)

    • 1

    案例实操1
    定义一个”二元运算函数，只操作1和2两个数，但是具体运算通过参数传入

    def dualFunctionOneAndTwo(fun:(Int,Int)=>Int):Int={
	fun(1,2)
}
//1
val add =(a:Int,b:Int)=>a+b
println(dualFunctionOneAndTwo(add)

//2
println(dualFunctionOneAndTwo((a:Int,b:Int)=>a+b))

//3
println(dualFunctionOneAndTwo((a,b)=>a+b))

//4
println(dualFunctionOneAndTwo(_+_))

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

    案例实操2
    定义一个函数func，它接收一个Int类型的参数，返回一个函数(记作fl1)。
    它返回的函数f1，接收一个string类型的参数，同样返回一个函数（记作2)。函数f2接
    收一个Char类型的参数，返回一个Boolean的值。
    要求调用函数func(0)(“”)(0)得到返回值为false，其它情况均返回true。
    简化前

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

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

    简化后

    def func(i: Int): String=>(Char=>Boolean) = {
  s=>c=>if (i == 0 && s == "" && c == '0') false else true
}
println(func(0)("")('0'))//false 

    • 1
    • 2
    • 3
    • 4

    柯里化

    def func(i:Int)(s:String)(c:Char):Boolean={
	if(i==0 && s=="" && c=="0") false else true
}

    • 1
    • 2
    • 3

    高阶函数

    高阶函数将其他函数作为参数或其结果是函数的函数。

    一、函数作为值进行传递

    def f(n:Int):Int={
	println("f调用")
	n+1
}

//val f1:Int=>Int=f
val f2 =f _

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    二、函数作为参数进行传递

        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,1,2))
    println(dualEval((a,b)=>a+b,1,2))
    println(dualEval(_+_,1,2))

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    三、函数作为返回值返回

    def f5(): Int=>Unit = {
  def f6(a: Int): Unit = {
    println("f6调用" +a)}
  f6   //将函数直接返回
}
//println(f5())//返回引用

val f6 =f5()
println(f6)//输出：
println(f6(25))
//输出：f6调用25
//     ()

println(f5()(25))
//输出：f6调用25
//     ()

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

    案例实操
    对数组进行处理，将操作抽象出来，处理完毕之后的结果返回一个新的数组

    val arr: Array [Int] = Array(12,45,75,98)
def array0peration(array: Array[Int],op: Int=>Int): Array[Int] = {
  for (elem <- array) yield op(elem)
}

//定义一个加一操作
def add0ne(elem: Int): Int = {
  elem + 1
}

//调用函数
val newArray: Array[Int] =array0peration(arr,add0ne)
println(newArray.mkString(" , "))//13 , 46 , 76 , 99


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

    柯里化函数

    以匿名函数案例实操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
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    该代码实现了函数的嵌套，func的返回值是f1，f1返回值是f2，f2返回的是基于条件判断的布尔类型的值。输出时以println(func(0)("")('0'))为例，调用func函数，传入参数0，得到(Char=>Boolean)函数返回值，相当于得到了f1的调用，此时，func的调用已经结束。i作为具备变量已经释放掉，最终在f2中，在语言理解层面是没办法取到i去做条件判断。
    **闭包：**能够读取其他函数内部变量的函数。在本质上，闭包是将函数内部和函数外部连接起来的桥梁。
    scala在调用函数时，创建一个对象实例，放到堆内存中。这个对象实例中打包了相关环境和局部变量。
    案例实操
    期望进行两树相加的操作，其中一个数我们希望固定好，但是熬以参数形式传入
    变更前

    def addBy4():Int=>Int={
	val a = 4
	def add(b:Int):Int={
	a+b
	}
	add
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    变更后

    def addByA():Int=>Int={
	val a = 4
	def add(b:Int):Int={
	a+b
	}
	add
}
println(addByA(35)(24))

val addByFour=addByA(4)
printlnaddByFour(12)

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

    lamda表达式简化

    def addByA(a:Int):Int=>Int = a + _

    • 1

    柯里化(Currying)函数是一个带有多个参数，并引入到一个函数链中的函数，每个函数都使用一个参数。函数柯里化的过程是把一个参数列表的多个参数，变成多个参数列表。

    def addCurrying(a:Int)(b:Int):Int={
	a+b
}
println(addCurrying(35)(24))

    • 1
    • 2
    • 3
    • 4

    递归

    一个函数/方法体内又调用了自身称为递归调用。
    阶乘案例

     // 1．循环实现
 def circle(n: Int) = {
   var result = 1
   for (i <- 1 to n) {
     result *= i
   }
   result
 }

 //2.递归实现
 def fact(n: Int):Int ={
   return fact(n-1)*n
 }

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

    上述递归实现虽然能够极大简化程序员编写代码的量，但是对计算机并不友好。return()会先拿到fact(n-1)的值，再将n与之相乘。当调用下一层函数时，内存仍保存有上一层的数据，极大增加了内存的消耗。为了解决这个问题，引入尾递归的概念,即指在一个方法内部，递归调用后直接return，没有任何多余的指令了。尾递归将外层方法的结果传递给了内层方法,当编译器检测到一个函数调用是尾递归的时候，它就覆盖当前的活动记录而不是在栈中去创建一个新的。这样在计算fact(4)时，会先将fact(5)弹栈，再将fact(4)压栈，保证同时只有一个栈帧在栈里存活

    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
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    传值参数和传名参数

    传值参数

    如下案例所示，定义一个Int类型的参数，调用这个参数的时候就把Int类型的值传给它，相当于变量赋值。

    scala
def f0(a: Int): Unit = {
   println("a: " + a)
   println("a: " + a)
 }
 f0(23)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    传名参数

    将一部分代码或代码块作为整体传递给参数，这个过程也叫名调用。

    def x():Int={
  println("x调用")
  12
}
def f1(a: =>Int): Unit = {
  println("a: " + a)
  println("a: " + a)
}
f1(x())

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    传名参数的这种调用方式是将a全部替换成x()代码块
    案例实操：自定义while循环
    常规的while循环

    var n: Int = 5
while (n >= 1) {
  println(n)
  n -= 1
}

    • 1
    • 2
    • 3
    • 4
    • 5

    用闭包实现一个函数，将代码块作为参数传入，递归调用

        def mywhile(condition: =>Boolean): (=>Unit)=>Unit = {
      //内层函数需要递归调用，参数就是符环体
      def doLoop(op: => Unit): Unit = {
        if (condition) {
          op
          mywhile(condition)(op)
        }
      }
      doLoop _
    }
    n=10
    mywhile(n>=1){
      println(n)
      n-=1
    }
  }

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

    用匿名函数实现

        def mywhile(condition: =>Boolean): (=>Unit)=>Unit = {
      //内层函数需要递归调用，参数就是符环体
       op=> {
        if (condition) {
          op
          mywhile(condition)(op)
        }
    }
    n=10
    mywhile(n>=1){
      println(n)
      n-=1
    }

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

    柯里化实现

        def mywhile(condition: =>Boolean)(op: => Unit):Unit = {
        if (condition) {
          op
          mywhile(condition)(op)
        }
    }
    n=10
    mywhile(n>=1){
      println(n)
      n-=1
    }

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

    惰性加载

    当函数返回值被声明为lazy时，函数的执行将被推迟，直到我们首次对此取值，该函
    数才会执行。这种函数我们称之为惰性函数。
    案例实操

        lazy val result:Int=sum(13,47)
    println("1.函数调用")
    println("1.result="+result)
  }
  def sum(a:Int,b:Int):Int={
    println("3.sum调用")
    a+b

//结果
//1.函数调用
//3.sum调用
//2.result=60

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

    lazy使sum(13,47)的求值过程变成了懒加载的过程，当前的result变量可以认为是传名参数，只有在第一次调用的时候才会执行（只调用一次sum函数）

  • 相关阅读:
    奇偶+逆序对构造法：arc102d
    【计算机网络】—网络编程（socket）02
    Linux常用的指令（2023.10.27）
    如何开启Docker的TCP通信端口
    Mysql ：创建数据库和管理数据库
    神经网络理论及应用,神经网络通俗易懂
    FFmpeg部分数据结构简介
    数据爬取京东，按时间划分的，手机价格，销量
    0065__git fetch, git pull, git merge, git rebase
    【C语言入门数据结构】顺序表
  • 原文地址：https://blog.csdn.net/weixin_47726676/article/details/126275454