Scala函数式编程

目录

一、函数式编程

1.1 函数基础

1.1.1 函数基本语法

1.1.2 函数和方法的区别

1.1.3 函数定义

1.1.4 函数参数

1.1.5 函数至简原则(重点)

1.2 函数高级

1.2.1 高阶函数

1.2.2 匿名函数

1.2.3 高阶函数案例(集合再讲)

1.2.4 函数柯里化&闭包

1.2.5 递归

1.2.6 控制抽象

1.2.7 惰性函数


一、函数式编程

1)面向对象编程

解决问题,分解对象,行为,属性,然后通过对象的关系以及行为的调用来解决问题。
对象:用户
行为:登录、连接JDBC、读取数据库
属性:用户名、密码
Scala语言是一个完全面向对象编程语言。万物皆对象
对象的本质:对数据和行为的一个封装

2)函数式编程

解决问题时,将问题分解成一个一个的步骤,将每个步骤进行封装(函数),通过调用这些封装好的步骤,解决问题。
例如:请求->用户名、密码->连接JDBC->读取数据库
Scala语言是一个完全函数式编程语言。万物皆函数。
函数的本质:函数可以当做一个值进行传递

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

1.1 函数基础

1.1.1 函数基本语法

1)基本语法

      

2)案例实操

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

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

        // 函数名(参数)

        f("hello world")

    }

}

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

1.1.3 函数定义

1)函数定义

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

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

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

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

(5)函数5:多参,无返回值

(6)函数6:多参,有返回值

2)案例实操

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.1.4 函数参数

1)案例实操

(1)可变参数

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

(3)参数默认值,一般将有默认值的参数放置在参数列表的后面

(4)带名参数

object TestFunction {
    def main(args: Array[String]): Unit = {
        // (1)可变参数
        def test( s : String* ): Unit = {
            println(s)
        }

        // 有输入参数:输出 Array
        test("Hello", "Scala")

        // 无输入参数:输出List()
        test()

        // (2)如果参数列表中存在多个参数,那么可变参数一般放置在最后
        def test2( name : String, s: String* ): Unit = {
            println(name + "," + s)
        }

        test2("jinlian", "dalang")

        // (3)参数默认值
        def test3( name : String, age : Int = 30 ): Unit = {
            println(s"$name, $age")
        }

        // 如果参数传递了值,那么会覆盖默认值
        test3("jinlian", 20)

        // 如果参数有默认值,在调用的时候,可以省略这个参数
        test3("dalang")


        // 一般情况下,将有默认值的参数放置在参数列表的后面
        def test4( sex : String = "男", name : String ): Unit =      {
            println(s"$name, $sex")
        }

      // Scala函数中参数传递是,从左到右
        //test4("wusong")

        //(4)带名参数
        test4(name="ximenqing")
    }
}

1.1.5 函数至简原则(重点)

函数至简原则:能省则省

1)至简原则细节

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

(2)如果函数体只有一行代码,可以省略花括号

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

(4)如果有return,则不能省略返回值类型,必须指定

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

(6)Scala如果期望是无返回值类型,可以省略等号

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

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

(9)如果不关心名称,只关心逻辑处理,那么函数名(def)可以省略

2)案例实操

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.2 函数高级

1.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)函数可以作为参数进行传递

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

1.2.2 匿名函数

1)说明

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

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

x:表示输入参数类型;Int:表示输入参数类型;函数体:表示具体代码逻辑

2)案例实操

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

传递匿名函数至简原则:

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

       需求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.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)
    }
}

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

1.2.5 递归

1)说明

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

2)案例实操

object TestFunction {
    def main(args: Array[String]): Unit = {

        // 阶乘
        // 递归算法
        // 1) 方法调用自身
        // 2) 方法必须要有跳出的逻辑
        // 3) 方法调用自身时,传递的参数应该有规律
        // 4) scala中的递归必须声明函数返回值类型

    println(fact(5))
    println(factorial(6))
    println(tailFactorial(10))
  }
//阶乘
  def fact(n: Int): Int = {
    var result: Int = 1
    for (i <- 1 to n ){
      result *=i
    }
    result
  }

  // 递归阶乘(缺点:内存一直占用,得不到释放,直到程序结束)
  def factorial(n: Int): Int = {
    if( n == 0) return 1
    n * factorial(n - 1)
  }

  //尾递归阶乘(优化普通递归)
  def tailFactorial(n: Int): Int = {
    @tailrec
    def loop(acc: Int,n: Int): Int = {
      if (n == 0) acc else  loop(n * acc,n - 1)
    }
    loop(1,n)
  }

}

1.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)案例实操

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

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

 

  • 1
    点赞
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值