【Scala】函数式编程

目录

定义

函数与方法区别

至简原则（最头疼的地方）

函数三种用法

1. 作为值进行传递

2.作为参数进行传递

3.作为函数返回值返回

匿名函数

传递匿名函数至简原则：

练习

柯里化&闭包

递归

控制抽象

值调用

名调用

惰性加载

高阶函数案例

Map 映射

filter 过滤

reduce 聚合

来源：

---

定义

def sum( x:Int, y:Int ) : Int={
    函数体
}

定义函数关键字 函数名(参数名：参数类型)：函数返回值类型={
    函数体
}

函数与方法区别

（ 1 ）为完成某一功能的程序语句的集合，称为函数。

（ 2 ）类中的函数称之方法。

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

（ 2 ）函数没有重载和重写的概念；方法可以进行重载和重写

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

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）return 可以省略，Scala 会使用函数体的最后一行代码作为返回值

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

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

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

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

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

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

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

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

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. 作为值进行传递

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.作为参数进行传递

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.作为函数返回值返回

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

匿名函数

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

传递匿名函数至简原则：

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

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。
  
 val fun = (i:Int, s:String, c:Char) =>{ if(i==0 && s=="" && c=='0') false else true  }

练习 2： 定义一个函数 func，它接收一个 Int 类型的参数，返回一个函数（记作 f1）。
它返回的函数 f1，接收一个 String 类型的参数，同样返回一个函数（记作 f2）。函数 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
      }
      //2 简化
      def func1(i: Int): String => (Char => Boolean) = {
        (s: String)=> {
          (c: Char)=> {
            if (i == 0 && s == "" && c == '0') false else true
          }
        }
      }
//参数类型都是确定的
        def func2(i: Int): String => (Char => Boolean) = {
          s => c => if (i == 0 && s == "" && c == '0') false else true
        }
      //柯里化
      def func3(i:Int)(s:String)(c:Char):Boolean={if (i == 0 && s == "" && c == '0') false else true}

柯里化&闭包

闭包：函数式编程的标配

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

环境，称为闭包

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

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

递归

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

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

尾递归优化

object Module_WeiDG {
  @tailrec 
  def story(): Unit = {
    println("从前有座山，山上有座庙，庙里有个老和尚，一天老和尚对小和尚讲故事")
    story()
  }
}

进入下一个函数，不再需要上一个函数的环境了，得出结果以后直接返回,即不为上一个函数保留栈帧。尾递归调用，可以被转化成循环，这样能节约栈空间

蹦床 TaiCalls

对于消除递归，一个更加通用的机制叫做“蹦床”。蹦床的实现会将执行一个循环，不停的调用函数。每个函数都返回下一个将被调用的函数。尾递归在这里是一个特例，每个函数都返回它自己。

import scala.util.control.TailCalls._
def evenLength(xs: Seq[Int]): TailRec[Boolean] = {
  if(xs.isEmpty) done(true) else tailcall(oddLength(xs.tail))
}

控制抽象

值调用

把计算后的值传递过去

名调用

传一个代码块

def f2(a: =>Int):Unit={
    执行次数根据 函数体a的调用次数
    也就是 将代码块整体带入
}

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

自定义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)
 }
 }
}

惰性加载

当 函数返回值被声明为 lazy 时 ，函数的 执行将被推迟 ，直到我们 首次对此取值，该函

数才会执行 。这种函数我们称之为惰性函数。

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

高阶函数案例

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

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

reduce 聚合

        
        def reduce(arr: Array[Int], op: (Int, Int) => Int) = {
          var init: Int = arr(0)
          for (elem <- 1 to arr.length) {
            println(elem)
            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)

来源：

尚硅谷

(16条消息) Scala 用于优化的注解（尾递归优化）_scala tailrec_样柏的博客-CSDN博客