学习链接：https://www.bilibili.com/video/BV1Xh411S7bP?p=48&spm_id_from=pageDriver

1 函数基础

1.1 基本语法

尚硅谷大数据技术之Scala.jpg

object Test01_FunctionAndMethod {
  def main(args: Array[String]): Unit = {
    // 定义函数
    def sayHi(name: String): Unit = {
      println("hi," + name)
    }
    // 调用函数
    sayHi("aaa") // 调用函数，hi,aaa；没有函数才会调用方法
    // 调用对象方法
    Test01_FunctionAndMethod.sayHi("bbb") // Hi,bbb
    // 获取方法返回值
    val result = Test01_FunctionAndMethod.sayHello("ccc")
    println(result) // Hello
  }
  // 定义对象的方法
  def sayHi(name: String): Unit = {
    println("Hi," + name)
  }
  // 有返回值的
  def sayHello(name: String): String = {
    println("Hi," + name)
    return "Hello"
  }
}

函数和方法的区别：

核心概念

为完成某一功能的程序语句的集合称为函数
类中的函数称为方法

Scala语言可以在任何的语法结构中声明任何的语法
函数没有重载和重写的概念，方法可以进行重载和重写
Scala中函数可以嵌套定义

1.2 函数定义

object Test02_FunctionDefine {
  def main(args: Array[String]): Unit = {
    // 1. 无参 无返回值
    def f1(): Unit = {
      println("1. 无参，无返回值")
    }

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

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

    // 4. 有参 有返回值
    def f4(name: String): String = {
      println("4. 有参，有返回值 " + name)
      return name
    }

    // 5. 多参 无返回值
    def f5(name1: String, name2: String): Unit = {
      println("多参,无返回值")
      println(s"${name1}和${name2}")
    }

    // 6. 多参，有返回值
    def f6(a: Int, b: Int): Int = {
      println("多参,有返回值")
      return a + b
    }
  }
}

1.3 函数参数

可变参数

def main(args: Array[String]): Unit = {
// 可变参数
def f1(str: String*): Unit = {
  println(str)
}

f1("aaa") // WrappedArray(aaa)
f1("aaa", "bbb", "ccc") // WrappedArray(aaa, bbb, ccc)
}

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

def main(args: Array[String]): Unit = {
// 如果参数列表中存在多个参数，可变参数一般放置在最后
def f2(str1: String, str2: String*): Unit = {
  println("str1:" + str1 + " str2:" + str2)
}

f2("aa") // str1:aa str2:WrappedArray()
f2("aa", "bb", "cc") // str1:aa str2:WrappedArray(bb, cc)
}

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

def main(args: Array[String]): Unit = {
// 参数默认值，一般将有默认值的参数放置在参数列表的后面
def f3(name: String = "aaa"): Unit = {
  println(name)
}
f3("bbb") // bbb
f3() // aaa
}

带名参数

def main(args: Array[String]): Unit = {
// 带名参数
def f4(name: String, age: Int): Unit = {
  println(s"${age}岁的${name}")
}

f4("aaa", 10)
f4(age = 13, name = "bbb") // 可以乱序
}

def main(args: Array[String]): Unit = {
// 带名参数
def f4(name: String = "aaa", age: Int): Unit = {
  println(s"${age}岁的${name}")
}

f4(age = 20) // 20岁的aaa
}

1.4 函数至简原则

def main(args: Array[String]): Unit = {
// 完整函数
def f0(name: String): String = {
  return name
}
println(f0("aaa")) // aaa

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

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

// 3. 返回值类型如果能推断出来，可以省略
def f3(name: String) = name
println(f3("ddd"))

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

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

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

// 7. 如果函数无参，但声明了参数列表，调用时小括号可以加可以不加
def f7(): Unit = {
  println("name")
}
f7 // name

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

// 9. 如果不关心名称，只关心逻辑处理，函数名def可以省略
// 匿名函数
(name: String) => {println(name)}
}

2 函数高级

2.1 匿名函数

(x: Int) => {函数体}
x：表示输入参数
Int：表示输入参数类型
函数体：表示具体代码逻辑 ```scala val fun = (name: String) => { println(name) } fun(“aaa”)

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

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


- 传递匿名函数至简原则
   - 参数的类型可以省略，会根据形参进行自动的推导
```scala
f((name) => {
  println(name)
})

类型省略之后，只有一个参数，则圆括号可以省略

其他情况：没有参数和参数超过1的永远不能省略圆括号

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

匿名函数如果只有一行，则大括号也可以省略
```
f(name => println(name))
```
如果参数只出现一次，则参数省略且后面参数可以用_代替
```
f(println(_))
```
如果可以推断出，当前传入的println是一个函数体，而不是调用语句，可以直接省略下划线
```
f(println)
```
实例：定义一个”二元运算”函数，只操作1和2两个数，但是具体运算通过参数传入 ```scala /**
- 实例
- 定义一个”二元运算”函数，只操作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)) // 3 println(dualFunctionOneAndTwo(minus)) // -1

```scala
// 匿名函数简化
println(dualFunctionOneAndTwo((a: Int, b: Int) => a + b)) // 3
println(dualFunctionOneAndTwo((a: Int, b: Int) => a - b)) // -1

// 再简化
println(dualFunctionOneAndTwo((a, b) => a + b))

// 再再简化
println(dualFunctionOneAndTwo(_ + _))

2.2 高阶函数

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

val result: Int = f(123)
println(result) // 124

函数作为值进行传递 ```scala // 1. 函数作为值进行传递 val f1: Int =>Int = f // 如果是没有参数的函数，()不能少 var f2:()=>Int = foo val f2 = f

println(f1) println(f1(12)) println(f2) println(f2(35))

![QQ截图20220530161604.png](https://cdn.nlark.com/yuque/0/2022/png/26273875/1653898574499-ee533bc9-2cab-4f7d-ac63-092e1c5eed02.png#clientId=ub39e5b23-2ba9-4&crop=0&crop=0&crop=1&crop=1&from=ui&height=137&id=ue37a3803&margin=%5Bobject%20Object%5D&name=QQ%E6%88%AA%E5%9B%BE20220530161604.png&originHeight=197&originWidth=727&originalType=binary&ratio=1&rotation=0&showTitle=false&size=22739&status=done&style=none&taskId=udaeae86f-5400-45fa-bd31-438cdeded7a&title=&width=504.766845703125)

2. 函数作为参数进行传递
```scala
// 2. 函数作为参数进行传递
// 定义二元计算函数
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, 12, 35))
println(dualEval((a, b) => a + b, 12, 35))
println(dualEval(_ + _, 12, 35))

函数作为函数的返回值返回 ```scala // 3. 函数作为函数的返回值返回 def f5(): Int => Unit = { def f6(a: Int): Unit = { println(“f6调用 “ + a) } f6 // 将函数直接返回 }

val f6 = f5() println(f6) // chapter05.Test06_HighOrderFunction$$$Lambda$10/1809787067@6b71769e println(f6(25)) // ()

// 或 println(f5()(25))

**举例：**
```scala
object Test07_Practice_CollectionOperation {
  def main(args: Array[String]): Unit = {
    val arr: Array[Int] = Array(12, 45, 75, 98)

    // 对数组进行处理,将操作抽象出来,处理完毕之后的结果返回一个新的数组
    def arrayOperation(array: Array[Int], op: Int => Int): Array[Int] = {
      for (elem <- array) yield op(elem)
    }

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

    // 调用函数
    val newArray: Array[Int] = arrayOperation(arr, addOne)

    println(newArray.mkString(","))

    // 传入匿名函数，实现元素翻倍
    val newArray2 = arrayOperation(arr, _ * 2)
    println(newArray2.mkString(","))
  }
}

object Test08_Practice {
  def main(args: Array[String]): Unit = {
    // 练习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
    }
    println(fun(0, "", '0')) // false
    println(fun(0, "", '1')) // true
    println(fun(23, "", '0')) // true
    println(fun(0, "hello", '0')) // 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
    }

    println(func(0)("")('0')) // true

    // 匿名函数简写
    def func1(i: Int): String => (Char => Boolean) = {
      s => c => if (i == 0 && s == "" && c == '0') false else true
    }
  }
}

2.3 函数柯里化&闭包

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

object Test09_ClosureAndCurrying {
  def main(args: Array[String]): Unit = {
    def add(a: Int, b: Int): Int = {
      a + b
    }

    // 1. 考虑固定一个加数的场景
    def addByFour(b: Int): Int = {
      4 + b
    }

    // 2. 扩展固定加数改变的情况
    def addByFive(b: Int): Int = {
      5 + b
    }

    // 3. 将固定加数作为另一个参数传入，但是是作为"第一层参数"传入
    def addByFour1(): Int => Int = {
      val a = 4

      def addB(b: Int): Int = {
        a + b
      }

      addB
    }

    def addByA(a: Int): Int => Int = {
      def addB(b: Int): Int = {
        a + b
      }

      addB
    }

    println(addByA(35)(24))

    val addByFour2 = addByA(4)
    val addByFive2 = addByA(5)

    println(addByFour2(13))
    println(addByFive2(25))

    // lambda表达式简写
    def addByA1(a: Int): Int => Int = {
      (b: Int) => {
        a + b
      }
    }

    // 简化
    def addByA2(a: Int): Int => Int = {
      b => a + b
    }

    // 再简化
    def addByA3(a: Int): Int => Int = a + _
  }
}

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

// 柯里化
def addCurrying(a: Int)(b: Int): Int = {
  a + b
}
println(addCurrying(35)(24))

2.4 递归

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 // 返回值不在最后一行，不能省略return
    fact(n - 1) * n
  }

  // 尾递归实现
  def tailFact(n: Int): Int = {
    @tailrec // 可以加注解表示是尾递归
    def loop(n: Int, currentResult: Int): Int = {
      if (n == 0) return currentResult
      loop(n - 1, currentResult * n)
    }

    loop(n, 1)
  }
}

2.5 控制抽象

值调用

object Test11_ControlAbstraction {
def main(args: Array[String]): Unit = {
 // 1. 传值参数
 def f0(a: Int): Unit = {
   println(a)
 }

 def f1(): Int = {
   println("f1调用")
   12
 }

 f0(f1())
}
}

QQ截图20220531113357.png

名调用：把代码传递过去 ```scala def f1(): Int = { println(“f1调用”) 12 }

// 2. 传名参数，传递的不是具体的值，而是代码块 // 代码块，返回值是Int，没有参数 def f2(a: => Int): Unit = { println(a) println(a) }

f2(23) // 23也是代码块，只有一行省略{} f2(f1()) // f1()作为参数，在f2()中被调用了两次

![QQ截图20220531120311.png](https://cdn.nlark.com/yuque/0/2022/png/26273875/1653969797255-522f1c25-46da-450a-b1d7-e3134da9bb3c.png#clientId=u3d473be3-2a3e-4&crop=0&crop=0&crop=1&crop=1&from=ui&height=153&id=u71a17812&margin=%5Bobject%20Object%5D&name=QQ%E6%88%AA%E5%9B%BE20220531120311.png&originHeight=198&originWidth=308&originalType=binary&ratio=1&rotation=0&showTitle=false&size=5644&status=done&style=none&taskId=ubdcd1e99-ba26-4f27-ab36-cf571870c1c&title=&width=237.9927978515625)
```scala
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 _
    }

    n = 10
    myWhile(n >= 1)({
      println(n)
      n -= 1
    })

    // 3. 用匿名函数实现
    def myWhile2(condition: => Boolean): (=> Unit) => Unit = {
      // 内层函数需要递归调用，参数就是循环体
      op => {
        if (condition) {
          op
          myWhile2(condition)(op)
        }
      }
    }

    n = 10
    myWhile2(n >= 1) {
      println(n)
      n -= 1
    }

    // 3. 用柯里化实现
    def myWhile3(condition: => Boolean)(op: => Unit): Unit = {
      if (condition) {
        op
        myWhile3(condition)(op)
      }
    }

    n = 10
    myWhile3(n >= 1) {
      println(n)
      n -= 1
    }
  }
}

2.7 惰性加载

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

object Test13_Lazy {
  def main(args: Array[String]): Unit = {
    lazy val result: Int = sum(13, 47)

    println("1. 函数调用")
    println("2. result = " + result)
  }

  def sum(a: Int, b: Int): Int = {
    println("3. sum调用")
    a + b
  }
}

QQ截图20220531164623.png

【Scala笔记】5.函数式编程