Scala基础5——第5章：函数式编程

第5章：函数式编程

（1）面向对象编程

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

​ 对象：用户

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

​ 属性：用户名、密码

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

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

（2）函数式编程

​ 不断的对表达式求值 y=f(x)

5.1 函数基本语法

（1）基本语法

// sum函数名
// (x:Int,y:Int)参数名，参数类型
// : Int = {} 返回值类型
def sum(x:Int , y:Int) : Int = {
    x + y //返回值
}

函数和方法的区别

​ 类中的函数称之为方法

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

scala可以在方法中定义函数

object Test01_FunctionAndMethod{
    def main(args:Array[String]):Unit={
        
        //定义函数
        def sayHi(name:String):Unit={
            println("你好，"+ name)
        }
        
        // 调用函数
        sayHi("alice") //你好，alice    
    	
    	// 调用对象方法
        Test01_FunctionAndMethod.sayHi("Tom")// 你好啊，Tom
        
        // 获取方法返回值
        val result = Test01_FunctionAndMethod.sayHello("aaa")
        print(result)
    }
    
    def sayHi(name:String):Unit={
        println("你好啊，"+name)
    }
    
    def sayHello(name:String):String={
        println("Hi,"+name)
        return "hello"
    }
}

object Test02{
    def main(args:Array[String]):Unit={
        // 无参，无返回值
        def f():Unit={
        	println("无参，无返回值")    
        }
        print(f())
        
        //无参，有返回值
        def f2():Unit={
            println("无参，有返回值")
        }
        
        // 有参，无返回值
        def f3(name:String):Unit={
            print("有参，无返回值")
        }
        
        // 有参，有返回值
        def f4(name:String):String={
            println("有参，有返回值 " + name)
        }
        
        // 多参，无返回值
        def f5(name1:String,name2:String):Unit={
            print("多参，无返回值")
        }
        
        // 多参，有返回值
        def f6(a:Int,b:Int):Int={
            return a+b
        }
    }
}

5.1.4 函数参数

​ （1）可变参数，可变参数放在最后

​ （2）设置参数的默认值

​ （3）带名传递参数

object Test03{
    def main(args:Array[String]):Unit={
        // (1)可变参数
        def f1(str:String*):Unit={
            print(str)
        }
        f1("a","b","c")
        // WrappedArray(a,b,c)
        f1("a","b","c","d")
        // WrappedArray(a,b,c,d)
        
        // (2)如果有多个参数，可变参数要放在最后
        def f2(str1:String , str2:String*):Unit={
            print(str1)
            print(str2)
        }
        f2("a","b","c")
        
        // (3)参数的默认值
        def f3(name:String = "默认值") : Unit={
            print(name)
        }
        f3() // 设置为默认值
        
        // (4)带名参数，根据参数名直接传参
        def f4(name:String,age:Int):Unit={
            println(s"${name}的年龄是${age}")
        }
        f4(age=10 , name="zhangsan")     
    }
}

5.1.5 函数至简原则

​ 对于函数，能省则省。

// 函数至简原则

object Test04{
    def main(args:Array[String]):Unit={
        
        def f0(name:String):String={
            return name
        }
        println(f0("zhangsan"))
        
        // (1) return 可以省略,把函数的最后一句作为返回值
        def f1(name:String):String={
            name
        }
        
        // (2) 只有一行代码，可以省略花括号
        def f2(name:String):String = name
        
        // (3) 如果返回值类型可以推断，也可以省略
        def f3(name:String) = name
        
        // (4) 如果有return，则不能省略返回类型
        def f4(name:String):String={
            return name
        }
        
        // (5) 如果返回值类型为Unit，则return不起作用
        def f5(name:String):Unit={
            return name
        }
        
        // (6) Scala 如果是无返回值，可以省略等号
        def f6(name:String){
            println(name)
        }
        
        // (7)如果函数无参，调用时可省略括号
        def f7()：Unit={
            print("hello")
        }
        f7()
        f7 // 等价于 f7()
        
        // (8) 如果函数无参，声明时也可以省略
        def f8:Unit={
            println("hello")
        }
        f8 // 调用f8
        
        // (9) lambda表达式 函数名，def都可以省略
        (name:String) => { println(name) }
        
        
    }
}

5.2 匿名函数

object Test06{
    def main(args:Array[String]):Unit={
        val fun = (name:String) => { println(name) }
        fun("atguigu")
        
        // 定义一个函数，以函数作为参数
        // 参数的类型是 String => Unit
        def f(func: String => Unit):Unit={
            func("school")
        }
        
        f(fun) // 把fun作为参数传递进去
        
    }
}

匿名函数的简化原则

object Test07{
    def main(args:Array[String]):Unit={
        
        def f(func: String => Unit):Unit={
            func("school")
        }
        
        // (1)参数的类型可以省略，会根据形参自动推断
        f( (name) => { println(name) } )
        
        // (2) 只有一个参数，括号可以省略
        f( name => { println(name) } )
        
        // (3) 匿名函数只有一行，大括号也可以省略
        f( name => println(name) )
        
        // (4) 如果参数只出现一次，可以用_代替
        f(  print(_) )
        
        // (5)如果可以推断出，当传入的println是一个函数体，而不是调用语句，可以直接省略下划线
        f( println )
        
    }
}

object Test07{
    def main(args:Array[String]):Unit={
        // 定义一个二元运算符
        def fun(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(fun(add))
        println(fun(minus))
        
        // 匿名函数简化
        println(fun((a:Int,b:Int) =>  a + b))
        println(fun((a:Int,b:Int) => a - b))
        
        print(fun( (a,b)=> a + b ))
        print( fun( _ + _ ) )
        print( fun( _ - _ ) )
        print( fun( -_ + _ ) )
        
                
    }
}

5.3 高级函数

5.3.1 高阶函数

​ （1）函数可以值进行传递

​ （2）函数可以作为参数传递

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

object Test06{
    def main(args:Array[String]):Unit={
        
        def f(n: Int): Int = {
            println("f调用")
            n + 1
        }
        
        val result: Int = f(123)
        println(result)
        
        // 1. 函数可以值进行传递
        val f1:Int=>Int = f // 表示f这个函数
        val f2 = f _ // 如果省略函数类型，则需要加_
        //val f3 = f //!!!报错，系统认为你是在调用f函数
        
        println(f1)
        println(f1(12))
        println(f2)
        println(f2(23))
        
        
    }
}

（2）函数可以作为参数传递

object Test07{
    def main(args:Array[String]):Unit={
        
        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))
    }
}

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

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

val f7:Int=>Unit = f5()  // 得到f6这个函数
print(f7)
print(f7(25)) 
// 输出结果
// 调用f6 25

f5()(26)
// 输出结果
// 调用f6 26

函数对集合进行操作

object Test07{
    def main(args:Array[String]):Unit={
        // 对数组进行处理，将操作抽象出来，处理完毕之后的结果返回一个新的数组
        def arrayOperation(array:Array[Int],op:Int=>Int):Array[Int]={
            for (element <- array) yield op(element)
        }
        
        // 定义一个数组
        val arr:Array[Int] = Array(23,44,32,100)
        // 定义一个操作
        def addOne(element:Int):Int={
            element + 1
        }
        // 调用函数
        val newArray:Array[Int] = arrayOperation(arr,addOne)
        println(newArray.mkString(",")) // 打印数组内容
        
        // 使用lambada表达式进行调用
        val newArrays2 = arrayOperation(arr,elem=>elem*2)
        val newArrays3 = arrayOperation(arr, _ * 2 )
    }
}

5.3.2 高阶函数练习

object Test08{
    def main(args:Array[String]):Unit={
        // 定义一个lambda表达式
        val fun= (i: Int, s:String, c:Char) =>{
            if (i==0 && s== "" && c=='0') false
            else true
        }
        
        println(fun(0,"","0"))
    }
}

object Test08{
    def main(args:Array[String]):Unit={
        
        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
        }
        
        print(func(0)("")('0'))    
    }
}

object Test08{
    def main(args:Array[String]):Unit={
        // 使用匿名函数改写
        def func(i:Int) : String=>(Char=>Boolean) = {
            s =>{
                c => if(i==0 && s=="" && c=='0') false else true
            }
        }
        
        print(func(0)("")('0'))   
        
        // 使用柯里化的方式改写
        def fun2(i:Int)(s:String)(c:Char):Boolean={
            if(i==0 && s=="" && c=='0') false else true
        }
        print(func(0)("")('0'))
        
    }
}

5.3.3 函数柯里化 和 闭包

​ 闭包： 如果一个函数，定义的内部函数调用了外部函数的值，称之为闭包

object Test09{
    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
        }
        
        // 使用闭包。。。
        // 4 将固定加数作为另一个参数传入，作为“第一层参数”传入
        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)
        addByFour2(10)
        addByFive2(20)        
    }
}

使用lambda表达式进行简写闭包

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

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

def addByA3(a:Int):Int=>Int={
    a + _
}

函数柯里化 Currying

用柯里化的形式可以简化闭包的代码。

柯里化的底层就是闭包

object Test09{
    def main(args:Array[String]):Unit={
        
        def addCurring(a:Int)(b:Int) : Int = {
            a + b
        }
        
        println(addCurring(3)(5))
        
    }
}

5.3.4 递归

​ 递归：一个函数在内部又调用了自身

例子：使用递归计算阶乘

java代码：

public class TestRecursion{
    public static void main(String[] args){
        System.out.println(factorial(5))
    }
    
    public static int factorial(int n){
        if( n < 0)
            return -1
        if(n == 0 || n==1)
            return 1
        else
            return n * factorial(n-1)
    }
}

scala代码：

object Test10{
    def main(args:Array[String]):Unit={
        println(fact(5))
    }
    
    def fact(n:Int):Int={
        if (n==0) return 1
        else n * fact(n-1)
    }
    
}

尾递归

为了节省递归调用的栈内存，可以使用尾递归调用进行优化

尾递归在Java中优化无效，尾递归主要跟编译器有关，当编译器知道是尾递归时，就会把栈中的指针数据覆盖，这样就能保证栈中的调用永远都只有一个。

// 用scala实现尾递归调用
def tailFact(n:Int):Int={
    @tailrec //@tailrec 保证写的代码是尾递归代码
    def loop(n:Int, currentRes:Int):Int={
        if (n==0) return currentRes
        loop(n-1 , currentRes * n)
    }
    loop(n,1)
}

5.3.5 控制抽象

（1）值调用：把计算后的值(f1计算后的值)传递进去

object Test11{
    def main(args:Array[String]):Unit={
        // 传值参数
        def f0(a:Int):Unit={
            println("a: "+ a)
            println("a: "+ a)
        }
        f0(23)
        
      	def f1():Int={
            println("f1调用")
            12
        }
        f0(f1())
    }
}

（2）名调用：把代码传递进去

把一段代码块作为参数传递进去

object Test11{
    def main(args:Array[String]):Unit={
        
        def f1():Int={
            println("f1调用")
            12
        }
        
        // => Int 表示最终计算的结果为Int类型的代码块
        def f2(a:  => Int):Unit={
            println("a: "+a) //这里的a表示调用一次a函数
            println("a: "+a) //这里的a表示调用一次a函数
        }
        f2(23) // 23 则是一个特殊的代码块，其只有一个数字
        f2(f1()) //f1() 表示一段代码块 
        
        f2({
            println("这是一个代码块")
            99
        }) // 传递代码块
    }
}

使用传名参数，自定义while循环

object Test12{
    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
        })
        // 括号可以省略
        myWhile(n >= 1){
            println(n)
            n -= 1
        }
        
        
        // 3 使用匿名函数,实现while循环
        def myWhile2(condition: => Boolean) (=>Unit)=>Unit = {
            // 内存函数需要递归调用，参数就是循环体
            op => {
                if (condition){
                    op // 执行内部代码块
                    myWhile(condition)(op) // 继续下一轮循环
                }
            }  
        }
        
        
        // 4 使用柯里化，实现while循环 
        def myWhile3(condition: => Boolean)(op: => Unit):Unit = {
            if (condition){
            	op // 执行内部代码块
            	myWhile(condition)(op) // 继续下一轮循环
             }
        }
        
        
    }
}

5.3.6 惰性加载

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

object Test13{
    def main(args:Array[String]):Unit={
        lazy val result: Int = sum(13,47) // 并不会立即执行
        
        println("1. 函数调用")
        println("2. result=" + result) // 用到的时候，再执行函数sum(13,47)
        println("4. result=" + result)
    }	
    
    def sum(a:Int, b:Int):Int={
        println("3. sum调用")
        a + b
    }
}
// 输出结果
// 1. 函数调用
// 3. sum调用
// 2. result=60
// 4. result=60