（二）Scala语言——函数式编程

最新推荐文章于 2024-08-05 20:09:54 发布
最新推荐文章于 2024-08-05 20:09:54 发布
阅读量751 收藏 4
点赞数
分类专栏： Scala 文章标签： Scala
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fseast/article/details/100532373
版权

目录

接上篇：（一）Scala语言——入门

一、函数式编程

1）面向对象编程
 解决问题，分解对象，行为，属性，然后通过对象的关系以及行为的调用来解决问题。
 对象：用户；
 行为：登录、连接jdbc、读取数据库。
 属性：用户名、密码。
 Scala语言是一个完全面向对象编程语言。万物皆对象。

2）函数式编程
 解决问题时，将问题分解成一个一个的步骤，将每个步骤进行封装(函数)，通过调用这些封装好的步骤，解决问题。
 例如：请求->用户名、密码->连接jdbc->读取数据库
 Scala语言是一个完全函数式编程语言。万物皆函数(万物皆函数不太对)
 函数可以当做一个值进行传递，高阶函数。
3）在Scala中函数式编程和面向对象完美编程融合在一起了。

4）函数（算子），方法：
 其实是一个东西，只是场景不一样，叫法不一样，在函数式编程习惯叫函数。

1. 函数基本语法

函数的签名：
 def add(a:Int,b:Int):Int
 三要素：函数名 形参列表 返回值类型

  1. 基本语法
    在这里插入图片描述
  2. 实操
package com.fseast.scala002.fun

object TestFunction {

  def main(args: Array[String]): Unit = {
    //2. 函数调用
    f("Hello World")
  }

  //1. 函数声明
  def f(s:String): Unit ={
    print(s)
  }
}

名词解释
一、纯函数： 特点：

  1. 不产生副作用。 常见的副作用：打印到控制台，修改了外部变量的值，向磁盘写入文件，…
  2. 引用透明， 函数的返回值，只和形参有关，和其他任何的值没有关系 纯函数的好处：天然的支持高并发，

二、只有副作用，没有返回值，叫过程。

细节：

  1. 函数体内可以没有return，这个时候会自动的把最后一行代码的值返回。

  2. 返回值类型也可以省略（：和返回值类型一起省），scala 会根据最后一行代码的值进行推导返回值类型。

  3. 如果有return， 则不能省略返回值类型，必须指定

  4. = 省略的话，表示这个函数一定返回的是 Unit， 不管函数体怎么定义，一定返回Unit。
    返回Unit 的函数， 有时候称为过程。

  5. 如果函数的形参格式是0，则调用的时候，可以省略（）

  6. 如果没有形参，则声明的时候也可以省略（），调用的就不能再有圆括号，和val的声明要区别。

  7. 可变参数

  8. 参数的默认值
    当传递时不传，则会使用默认值。

  9. 命名参数：
    调用的时候，指定形参的名字。

2. 函数和方法的区别

个人理解是方法和函数其实是一个东西，只是场景不一样，叫法不一样，在函数式编程习惯叫函数。
（1）Scala语言的语法非常灵活，可以在任何的语法结构中声明任何的语法
（2）函数没有重载和重写的概念；方法可以进行重载和重写
（3）scala中函数可以嵌套定义

3. 函数声明和函数参数

  1. 函数的声明
    （1）函数1：无参，无返回值
    （2）函数2：无参，有返回值
    （3）函数3：有参，无返回值
    （4）函数4：有参，有返回值
    （5）函数5：多参，无返回值
  2. 实例实操
    （1）可变参数
    （2）如果参数列表中存在多个参数，那么可变参数一般放置在最后
    （3）参数默认值
    （4）带名参数
package com.fseast.scala002.fun

object TestFunction2 {
  def main(args: Array[String]): Unit = {
    //1. 测试可变参数
//    test1("11test","jjj")
    
    //2. 测试可变参数2，
    //test2("t11","t22")
    
    //3. 测试参数默认值,带名参数
    test3("fsd",t = 22)
  }
  
  //1. 可变参数
  def test1(s:String*)={
    println(s)
  }
  
  //2. 如果参数列表中存在多个参数，那么可变参数一般放置在最后
  def test2(name:String,s:String*)={
    println(name + "," + s)
  }
  
  //3. 参数默认值
  def test3(name:String,age:Int = 30,t:Int)  ={
    println(name,age)
  }
  

}

4. 函数至简原则

函数至简原则：能省则省

1）至简原则细节
（1）return可以省略，Scala会使用函数体的最后一行代码作为返回值
（2）返回值类型如果能够推断出来，那么可以省略
（3）如果函数体只有一行代码，可以省略花括号
（4）如果函数无参，则可以省略小括号。若定义函数时省略小括号，则调用该函数时，也需省略小括号；若定时函数时未省略，则调用时，可省可不省。
（5）如果函数明确声明Unit，那么即使函数体中使用return关键字也不起作用
（6）Scala如果想要自动推断无返回值，可以省略等号
（7）如果不关心名称，只关系逻辑处理，那么函数名（def）可以省略
（8）如果函数明确使用return关键字，那么函数返回就不能使用自行推断了，需要声明返回值类型

2）案例实操

        // 0）函数标准写法
        def f1( s : String ): String = {
            return s + " jinlian"
        }
        println(f1("Hello"))

        // 至简原则:能省则省

        //（1） return可以省略,scala会使用函数体的最后一行代码作为返回值
        def f2( s : String ): String = {
            s + " jinlian"
        }
        println(f2("Hello"))

        // 如果函数名使用return关键字，那么函数就不能使用自行推断了,需要声明返回值类型
        /*
        def f22(s:String)={
            return "jinlian"
        }
        */
        
        //（2）返回值类型如果能够推断出来，那么可以省略
        def f3( s : String ) = {
            s + " jinlian"
        }

        println(f3("Hello"))

        //（3）如果函数体只有一行代码，可以省略花括号
        //def f4(s:String) = s + " jinlian"
        //def f4(s:String) = "jinlian"
        def f4() = " dalang"

        // 如果函数无参，但是声明参数列表，那么调用时，小括号，可加可不加。
        println(f4())
        println(f4)

        //（4）如果函数没有参数列表，那么小括号可以省略,调用时小括号必须省略
        def f5 = "dalang"
        // val f5 = "dalang"

        println(f5)

        //（5）如果函数明确声明unit，那么即使函数体中使用return关键字也不起作用
        def f6(): Unit = {
            //return "abc"
            "dalang"
        }
        println(f6())

        //（6）scala如果想要自动推断无返回值,可以省略等号
        // 将无返回值的函数称之为过程
        def f7() {
            "dalang"
        }
        println(f7())

        //（7）如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略
        //()=>{println("xxxxx")}
        val f = (x:String)=>{"wusong"}

        // 万物皆函数 : 变量也可以是函数
        println(f("ximenqing"))

        //（8）如果函数明确使用return关键字，那么函数返回就不能使用自行推断了,需要声明返回值类型
        def f8() :String = {
            return "ximenqing"
        }
        println(f8())

5. 高阶函数

1）说明：
  一个函数，可以接收一个函数作为参数，这样的函数就叫高阶函数（高阶算子）。
对一个函数做什么？
（1）定义函数
（2）调用函数
（3）传递函数

2）案例实操1

object HighDemo1 {
  def main(args: Array[String]): Unit = {
    //把函数 add 当做参数传到 f1 函数中
    println(f1(add))
    
  }
  
  def add(i1:Int,i2:Int)={
    i1 + i2
  }
  def f1(f:(Int,Int)=>Int)={
    f(3,5)
  }
  
}

案例实操2：高阶函数常用的场景

object HighDemo2 {
  def main(args: Array[String]): Unit = {
    operation(Array(1,2,3,4,5),op)
  }
  
  
  def op(i: Int)={
    println(i + i)
  }
  
  def operation(arr:Array[Int],op:Int=>Unit)={
    for (i <- arr) {
      //遍历第一个参数（数组）的内容，当做参数传到第二次参数（函数）中
      op(i)
    }
  }
  
}

6. 匿名函数

1）需求：
通过上面高阶函数的案例2中可以发现，每次如果要把一个函数当做参数传到另一个函数时，要写一个函数，而且该函数有可能只用一次，不够优雅。
2）说明：
没有名字的函数就是匿名函数，可以直接通过函数字面量（λ表达式）来设置匿名函数，函数字面量定义格式如下。

3）案例实操

object HighDemo2 {
  def main(args: Array[String]): Unit = {
    //版本1：原版匿名函数
   operation(Array(1,2,3,4,5),(ele:Int) =>{
      println(ele+ele)
    })

    /**省略版本：
      * 1.参数的类型可以省略，
      * 2.类型省略之后，只有一个参数，则圆括号可以省略，
      * 其他的情况：没有参数和参数超过1 永远不能省圆括号
      * 3. 匿名函数如果只有一行，则大括号也可以省略。
      */
    //版本2：省略了参数类型和圆括号（只有一个参数所以圆括号可以省）
    operation(Array(1,2),ele=>{
      println(ele + 1)
    })
    //版本3：只有一行 大括号可以省略
    operation(Array(1,2),ele => println(ele + 1))
    //版本4：只有一行，且格式简单，用占位符替代：形参只使用一次
    operation(Array(1,2), _+1)
    
  }
    
  def operation(arr:Array[Int],op:Int=>Unit)={
    for (i <- arr) {
      //遍历第一个参数（数组）的内容，当做参数传到第二次参数（函数）中
      op(i)
    }
  }
  
}
6.1 高阶函数和匿名函数的使用案例

使用案例一：

object HighDemo4 {
  def main(args: Array[String]): Unit = {
    //把函数体x*x 传入到map中，
    var arr = map(Array(1,2,3,4),x => x * x)
    println(arr.mkString(","))
  }
  
  def map(arr:Array[Int],op: Int => Int)={
    for (i <- arr) yield op(i)
  }
}

使用案例二：
拦截

object HighDemo5 {
  def main(args: Array[String]): Unit = {
    //2. 测试拦截
    //下面这行代码可以省略为：val arr1 = filter(Array(1,2,3,4,5),_%2==1)
    val arr1 = filter(Array(1,2,3,4,5),x=>x%2==1)
    println(arr1.mkString(","))
  }

  //2. 拦截，
  def filter(arr: Array[Int], op: Int => Boolean): Array[Int] = {
    for (i <- arr if op(i)) yield i
  }
}

使用案例三：

object HighDemo4 {
  def main(args: Array[String]): Unit = {
    //3. 测试模拟reduce
    //下面这行代码可以省略为var red = reduce(Array(1,2,3,4),_+_)
    var red = reduce(Array(1,2,3,4),(x,y) => x + y)
    println(red)
  }

  //3. 模拟reduce
  def reduce(arr1: Array[Int],op1: (Int,Int) => Int)={
    var init = arr1(0)
    for (e1 <- 1 until arr1.length) {
      init = op1(init,arr1(e1))
    }
    init
  }
}

7. 闭包和函数柯里化

闭包：
函数式编程的标配

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

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

object ClosureDemo1 {
  def main(args: Array[String]): Unit = {
    //计算4+5的值
    println(add(4)(5))
    //也可以这样
    val add4 : Int => Int = add(4)
    println(add4(5))
    
    //测试函数的柯里化
    println(add1(2)(8))
  }


  def add(a: Int) = {
    //a是外部变量，闭包
    (b: Int) => a + b
    
  }
  
  //函数柯里化
  def add1(a:Int)(b:Int)=a+b
}

8. 递归调用

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

object RecusiveDemo {
  def main(args: Array[String]): Unit = {
    println(jieceng(10))
  }
  
  //计算阶层
  //递归调用的返回值类型不可以推
  def jieceng(n:Long):Long={
    if (n == 1) 1
    else n * jieceng(n-1)
  }
}

9. 控制抽象

值调用：把值传过去，就第一次计算。
名调用：把一段代码（表达式）传过去，用一次执行一次这段代码，

值调用和名调用：

object ControlAbs {
  def main(args: Array[String]): Unit = {
    //1. 值调用
    foo1(3+4)
    
    //2. 名调用
    foo2(3+5)
    
    def f()={
      println("--------")
      12
    }
    //值调用
    foo1(f())
    //名调用
    foo2(f())
    
    //
    foo3(() =>{
    13
    })
  }
  
  //1. 值调用
  def foo1(a: Int)={
    println(a)
    println(a)
    println(a)
  }
  
  //2. 名调用：传一个代码块
  def foo2(a: => Int)={
    println(a)
    println(a)
    println(a)
  }
  
  //3. 与2.名调用功能相似,传一个无参的函数，结果是<function0>
  def foo3(a: () => Int)={
    println(a)
    println(a)
    println(a)
  }
}

控制抽象：

object ControlAbs3 {
  def main(args: Array[String]): Unit = {
    var i = 1
    myWhile(i<=100){
      println(i)
      i += 1
    }
  }
  
  
  def myWhile(c: => Boolean)(op: => Unit):Unit ={
    if (c){
      op
      myWhile(c)(op)
    }
  }

}

10. 惰性函数

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

val a = {10} //立即求出来结果
lazy val b //第一次使用求值
def c = 30 //用一次求一次
fseast
关注
专栏目录
【编程语言】Scala 函数式编程
程序员光剑
02-25 1万+
函数是Scala中的一等公民。本文讨论Scala函数式编程的一些基本原理。你将会学到如何使用高阶函数，以及重用已有代码时，遵守 DRY 原则。Scala 的集合库很棒#So what does the above buy you anyway? The following are some examples from Scala’s own collections library.那么，以上这...
scala程序设计
sinat_27545249的博客
07-19 568
4.4 单例对象     在scala中创建单例对象使用object关键字，因为单例对象无法初始化，所以不能给他的主构造函数传递参数。    例子：
Scala中的函数式编程
热门推荐
周天祥的博客
11-19 7万+
Scala中的函数式编程 Scala程序设计 第2版 - 原版.pdf 下载：https://download.csdn.net/download/u014646662/10805074 作为一门面向对象与函数式的混合范式语言，Scala 并不强制要求函数必须是纯函数，也不要求变量不可变。尽管它的确推荐你在任何可能的情况下这么做。 以下是几个高阶函数，我们将其组合在一起，用它来对一个整数列表...
Scala基础入门：从零开始学习Scala编程
最新发布
weixin_41859354的博客
08-05 1442
Scala是由Martin Odersky于2003年设计的一种现代编程语言，其名称来源于“Scalable Language”（可扩展语言）。Scala运行在Java虚拟机（JVM）上，可以与Java进行无缝集成。它既支持面向对象编程，也支持函数式编程，允许开发者编写简洁、高效的代码。val：定义不可变变量（类似于Java中的finalvar：定义可变变量y = 30.5 // 允许修改// x = 15 // 不允许修改，会报错函数使用def// 函数体// 返回值使用class。
scala 函数式编程 foreach, map , flatmap , filter , exists ,sorted ,groupBy ,reduce ,fold
wz_TXWY的博客
09-16 1087
函数式编程 我们将来使用Spark/Flink的大量业务代码都会使用到函数式编程。下面的这些操作是学习的重点。 遍历（foreach） 映射（map） 映射扁平化（flatmap） 过滤（filter） 是否存在（exists） 排序（sorted、sortBy、sortWith） 分组（groupBy） 聚合计算（reduce） 折叠（fold） 遍历 | foreach 之前，学习过...
Scala语言中的函数
木子李下的博客
06-25 207
最近学Scala的函数有点灵活，和Java或者python都有不小的区别，不是很好理解，在此归纳总结一下。 一、匿名函数 传一个int型的参数进去，返回x+1。在后面的代码直接调用inc即可。Scala是变量名在前，类型在后。 var inc = (x:Int) => x+1 var x = inc(7)-1 二、函数柯里化 柯里化是将一起传入的多个参数单独分开 def add(x:Int,y:Int)=x+y #柯里化后 def add(x:Int)(y:Int) = x + y 其等价于有内含
scala语言——函数式编程
qq_30122883的博客
03-14 158
函数式编程基础 1、在scala中，方法和函数几乎可以等同，只是函数的使用方式更加的灵活多样 [方法转函数]。 函数式编程充分利用函数、 支持的函数的多种使用方式。 函数是一等公民，像变量一样，既可以作为函数的参数使用，也可以将函数赋值给一个变量. ，函数的创建不用依赖于类或者对象。 2、函数/方法的定义 def 函数名 ([参数名: 参数类型], ...)[[: 返回值类型] =] ...
Scala函数式编程
03-18
　这本书所讲授的，正是基于 Scala 的函数式编程基础。基于 Scheme、Haskell 等老牌函数式语言的传统教材的问题在于，相关语言的语法和思维方式与读者现有的知识体系迥异，容易造成较为陡峭的入门门槛。此外，由于...
Scala编程——第六章：Scala函数式编程高级（上）
lightupworld的博客
07-31 312
Scala函数式编程高级（上）一、作为值的函数二、函数字面量1.字面量2.函数字面量(匿名函数)3.函数字面量的简写(1)简写规则：(2)正确使用占位符三、带参数的函数四、高阶函数五、部分应用函数(Partially Applied Functions) 一、作为值的函数 在Scala中，函数是"头等公民"，就和数字一样，你可以在变量中存放函数。import scala.math._ val num = 3.14 val fun = ceil _ //注意有个下划线_ 这段代码将num设为3.14
Scala编程——第五章：Scala函数式编程（基础）
lightupworld的博客
07-29 1446
Scala函数式编程基础（上）一、概念说明1.方法与函数2.函数式编程与面向对象编程二、函数的定义1.基本语法2.函数的调用三、过程(procedure)1.基本概念四、惰性函数五、异常六、函数字面量 Scala函数式编程分成基础部分和高级部分。高级部分参考： 一、概念说明 1.方法与函数 方法： 定义函数最常用的方式是作为某个对象的成员。这样的函数被称为方法。 函数：在Scala中函数和方法几乎可以等同(定义、使用、运行机制都是一样的)，只是函数的使用方式更加灵活。 区别：Scala中函数是一等公民，像
scala与函数式编程——什么是函数式编程
samsai100的博客
06-13 1660
什么是函数式编程？　　函数式编程是一种面向函数和函数组合的编程方式。 　　什么是函数？从数学的角度，函数即Function，是从集合A到集合B的一种映射关系。如果集合A中的每一个元素都对应到集合B中的某一个元素，那么这种映射关系就叫做函数。比如每个人都有一个名字，那么“人”这个集合中的每一个元素，都能对应到String集合中的一个字符串，因此“将人通过名字映射到字符串”是一个函数，它的签名可以是m
Scala 程序设计 中+英文
10-24
Scala 程序设计第二版高清PDF，包含中文和英文 PDF 。干货！干货！
Scala语言的函数式编程
weixin_43520450的博客
05-07 338
1、Scala中的函数 在Scala中，函数是“头等公民”，就和数字一样。可以在变量中存放函数，即：将函数作为变量的值（值函数）。 2、匿名函数 3、带函数参数的函数，即：高阶函数 示例1： （1）首先，定义一个最普通的函数 （2）再定义一个高阶函数 （3）分析这个高阶函数调用的过程 示例2： 在这个例子中，首先定义了一个普通的函数mytest，然后定义了一个高阶函数myFunctio...
【Scala】函数式编程
HR的博客
03-07 783
函数式编程函数定义和使用高阶函数针对容器操作函数式编程实例 函数定义和使用 定义函数最通用的方法是作为某个类或者对象的成员，这种函数被称为方法，其定义的基本语法为 def 方法名(参数列表):结果类型={方法体} 字面量包括整数字面量、浮点数字面量、布尔型字面量、字符字面量、字符串字面量、符号字面量、函数字面量和元组字面量 函数字面量可以体现函数式编程的核心理念 在函数式编程中，函数是“头等公民”，可以像任何其他数据类型一样被传递和操作，也就是说，函数 的使用方式和其他数据类型的使用方式完全一致了
【连载】Scala程序设计：Java虚拟机多核编程实战——简介
图灵教育
08-13 5255
     可以在JVM上编程的语言有很多。通过这本书，我希望让你相信花时间学习Scala是值得的。      Scala语言为并发、表达性和可扩展性而设计。这门语言及其程序库可以让你专注于问题领域，而无需深陷于诸如线程和同步之类的底层基础结构细节。      如今硬件已经越来越便宜，越来越强大。很多用户的机器都装了多个处理器，每个处理器又都是多核。虽然迄今为止，Java对我们来说还不错，但它并不是为了利用我们如今手头的这些资源而设计的。而Scala可以让你运用这些资源，创建高响应的、可扩展的、高性能的应
Scala——函数式编程、面向对象
qq_42873479的博客
03-19 1130
Scala——函数式编程5 函数式编程5.1 函数基础5.2 函数高级5.2.1 匿名函数5.2.2 高阶函数5.2.3 高阶函数练习5.2.4 函数柯里化&闭包5.2.4 递归5.2.5 控制抽象5.2.6 惰性加载6 面向对象6.1 Scala包6.1.1 包的命名6.1.2 包说明（包语句）6.1.3 包对象6.1.4 包导入6.2 类和对象6.2.1 定义类6.2.2 属性6.3 封装6.4 继承和多态6.5 抽象类6.6 单例对象（伴生对象）6.7 特质（Trait）6.
Scala函数式编程特点
H_try_my_best的博客
06-11 404
（1）高阶函数（Higher-order functions） （2）闭包（closures） （3）模式匹配（Pattern matching） （4）单一赋值（Single assignment） （5）延迟计算（Lazy evaluation） （6）类型推导（Type inference （7）尾部调用优化（Tail call optimization） （8）类型推导（Type infe...
Scala 中的函数式编程
hongchenshijie的博客
01-17 801
文章目录1.遍历 (foreach)方法方法说明代码示例使用类型推断简化函数定义代码示例使用下划线来简化函数定义代码示例2.映射 (map)方法方法说明代码示例3.映射扁平化（flatmap）定义方法方法说明代码示例使用flatMap简化操作代码示例4.过滤（filter）方法方法说明代码示例5.是否存在（exists）方法方法说明6.排序（sorted、sortBy、sortWith）默认排序(...
Scala语言：集成面向对象和函数式编程的特性
xidajiancun
12-11 477
简介 Scala编程语言近来抓住了很多开发者的眼球。如果你粗略浏览Scala的网站，你会觉得Scala是一种纯粹的面向对象编程语言，而又无缝地结合了命令式和函数式的编程风格。Christopher Diggins认为： 不太久之前编程语言还可以毫无疑义地归类成“命令式”或者“函数式”。Scala代表了一个新的语言品种，它抹平了这些人为划分的界限。 根据David Rupp在博客中的说法，...
Scala语言基础：Spark编程基石（2/155）- 面向对象与函数式编程
章节分为四个部分：2.1 Scala语言概述，2.2 Scala基础，2.3 面向对象编程基础，以及2.4 函数式编程基础。 在2.1 Scala语言概述中，介绍了计算机编程的历史背景和发展。阿隆佐•邱奇的λ演算和图灵机是早期的重要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值