Scala-函数式编程

已于 2023-05-09 20:41:41 修改
阅读量115 收藏
点赞数
分类专栏： 开发语言 文章标签： scala 开发语言 后端
于 2023-05-01 10:51:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57697768/article/details/130448046
版权

Scala-函数式编程

一、函数基础

函数和方法的区别:
（1）为完成某一功能的程序语句的集合，称为函数。
（2）类中的函数称之方法。

1）面向对象编程

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

2）函数式编程

解决问题时，将问题分解成一个一个的步骤，将每个步骤进行封装（函数），通过调用这些封装好的步骤，解决问题。
例如：请求->用户名、密码->连接 JDBC->读取数据库
Scala 语言是一个完全函数式编程语言。万物皆函数。
函数的本质：函数可以当做一个值进行传递
这里的函数指的是数学意义上的函数y=f(x)，强调的是映射关系,对于传入的x都有y与之对应。

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

1.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.2 函数至简原则

至简原则:
（1）return 可以省略，Scala 会使用函数体的最后一行代码作为返回值

def f1( s : String ): String = {
 s + " jinlian"
 }
 println(f1("Hello")) #Hello jinlian

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

def f2(s:String):String = s + " jinlian"

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

def f3( s : String ) = s + " jinlian"

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

def f4() :String = {
 return "ximenqing4"
 }

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

 def f5(): Unit = {
 return "dalang5"
 }

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

 def f6() {
 "dalang6"
 }

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

 def f7() = "dalang7"

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

 def f8 = "dalang"

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

def f9 = (x:String)=>{println("wusong")}
 def f10(f:String=>Unit) = {
 f("")
 }
 
 f10(f9)
 println(f10((x:String)=>{println("wusong")}))
 #匿名函数 val func = ；-(name:String)=>{}
 }

二、函数高级

1）函数可以作为值进行传递

object TestFunction {
 def main(args: Array[String]): Unit = {
 （1）调用 foo 函数，把返回值给变量 f
 val f = foo //接收的是函数foo的返回值
 println(f)
 （2）在被调用函数 foo 后面加上 _，相当于把函数 foo 当成一个整体，传递给变量 f1
 val f1 = foo _
 foo()
 f1()
（3）如果明确变量类型，那么不使用下划线也可以将函数作为整体传递给变量
var f2:()=>Int = foo //定义一个变量,接收类型为返回Int类型数据的空参函数

def foo():Int = {
 println("foo...")
}

}

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():Int=>Unit = {
 	def f2(a:Int):Unit = {
 		print("f2调用"+a)
	}
	f2
}
val f = f1() //f=f2
// 因为 f1 函数的返回值依然为函数，所以可以变量 f 可以作为函数继续调用
f(25)
// 上面的代码可以简化为
f1()(25)
#结果： 
f6调用 25
() //f2的返回值为空

三、匿名函数

什么是匿名函数: 没有名字的函数就是匿名函数。
(x:Int)=>{函数体}
x：表示输入参数类型；Int：表示输入参数类型；函数体：表示具体代码逻辑

传递匿名函数至简原则：
（1）参数的类型可以省略，会根据形参进行自动的推导
（2）类型省略之后，发现只有一个参数，则圆括号可以省略；其他情况：没有参数和参数超过 1 的永远不能省略圆括号。
（3）匿名函数如果只有一行，则大括号也可以省略
（4）如果参数只出现一次，则参数省略且后面参数可以用_代替

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

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：定义一个匿名函数，并将它作为值赋给变量 fun。函数有三个参数，类型分别为 Int，String，Char，返回值类型为 Boolean。要求调用函数 fun(0, “”, ‘0’)得到返回值为 false，其它情况均返回 true。

object HelloWorld {
  def main(args: Array[String]): Unit = {
    val fun = (i:Int,s:String,c:Char)=>{
    if(i == 0 && s == "" && c== '0')false else true
    }
    println(fun(0,"",'0'))
  }
}

练习 2： 定义一个函数 func，它接收一个 Int 类型的参数，返回一个函数（记作 f1）。它返回的函数 f1，接收一个 String 类型的参数，同样返回一个函数（记作 f2）。函数 f2 接收一个 Char 类型的参数，返回一个 Boolean 的值。

object HelloWorld {
  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
    }
    println(func(0)("")('0'))
    #匿名函数的简写
    def func(i:Int):String=>(Char=>Boolean)={
      s=>c=>if(i == 0 && s == "" && c== '0')false else true
    }
    #柯里化
    def func(i:Int)(s:String)(c:Char):Boolean={
    	if(i == 0 && s == "" && c== '0')false else true
    }
    
  }
}

四、函数柯里化和闭包

闭包：函数式编程的标配
1）说明

闭包：如果一个函数，访问到了它的外部（局部）变量的值，那么这个函数和他所处的环境，称为闭包
函数柯里化：把一个参数列表的多个参数，变成多个参数列表。

（1）闭包

object TestFunction {
 def main(args: Array[String]): Unit = {
 	def f1(a:Int)={
 		def f2(b:Int)={
 			a + b
 		}
 	f2 _
 	}
 // 在调用时，f1 函数执行完毕后，局部变量 a 应该随着栈空间释放掉
 val f = f1(5)
 // 但是在此处，变量 a 其实并没有释放，而是包含在了 f2 函数的内部，形成了闭合的效果
 println(f(3))
 println(f1(5)(3))

  #函数柯里化，其实就是将复杂的参数逻辑变得简单化,函数柯里化一定存在闭包
 def f3(a:Int)(b:Int)={
 a + b
 }
 println(f3(5)(3))
 }
}

尾递归:

def tailFact(n:Int):Int ={
    def loop(n:Int,currRes:Int):Int={
      if (n==0) return currRes
      loop(n-1,currRes*n)
    }
    loop(n,1)
  }

在函数式编程中,递归会反复的调用函数并且没有释放父函数的资源,会进行持续的压栈,造成stack的内存溢出;使用尾递归,将每次递归的结果保留下来,将上一次的函数进行释放,降低资源使用率。

五、控制抽象

1）值调用：把计算后的值传递过去
// 将一个函数计算过后的值转递到另一函数中使用
2）名调用：把代码传递过去

object TestControl {
 def main(args: Array[String]): Unit = {
	def f = ()=>{
 		println("f...")
 	10
 	}
 foo(f())
 }

 def foo(a: =>Int):Unit = {//注意这里变量 a 使用=>Int 定义了代码块的返回值
 println(a)
 println(a)
 }
#名调用,每次调用a时f()代码块时都将执行一次
输出结果：
f...
10
f...
10

注意：Java 只有值调用；Scala 既有值调用，又有名调用。

5.1 惰性加载

当函数返回值被声明为 lazy 时，函数的执行将被推迟，直到我们首次对此取值，该函
数才会执行。这种函数我们称之为惰性函数。

def main(args: Array[String]): Unit = {
 lazy val res = sum(10, 30)
 println("1.函数调用")
 println("2.res=" + res)
}
def sum(n1: Int, n2: Int): Int = {
 println("3.sum 被执行。。。")
 return n1 + n2
}
#结果:
1.函数调用
3.sum被执行。。。
2.res=40

注意：lazy 不能修饰 var 类型的变量

Aimyon_36
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
Scala函数式编程笔记
weixin_41074929的博客
08-20 1577
Scala中函数可以不依赖于类、对象、接口单独存在，函数可以作为函数的参数、返回值。 scala&amp;gt; def fun1(name:String){println(name)} //定义函数 fun1: (name: String)Unit scala&amp;gt; val fun1_v = fun1 _ //将函数赋值给fun1_v fun1_v: String =&amp;gt; Unit = &amp;...
scala 函数式编程 foreach, map , flatmap , filter , exists ,sorted ,groupBy ,reduce ,fold
wz_TXWY的博客
09-16 1045
函数式编程 我们将来使用Spark/Flink的大量业务代码都会使用到函数式编程。下面的这些操作是学习的重点。 遍历（foreach） 映射（map） 映射扁平化（flatmap） 过滤（filter） 是否存在（exists） 排序（sorted、sortBy、sortWith） 分组（groupBy） 聚合计算（reduce） 折叠（fold） 遍历 | foreach 之前，学习过...
Scala之函数式编程
Trony的博客
02-20 152
一、多范式编程 面向对象编程：解决问题时，分解对象，行为，属性，然后通过对象的关系以及行为的调用来解决问题。 Scala语言是一个完全面向对象编程的语言。万物皆对象 对象的本质：对数据和行为的一个封装 函数式编程：解决问题时，将问题分解成一个一个的步骤，将每个步骤进行封装（函数），通过调用这些封装好的步骤，解决问题 Scala语言是一个完全函数式编程语言。万物皆函数。 函数的本质：函数可以当做一个值进行传递 在Scala中函数式编程和面向对象编程完美融合在一起了。 二、函数基础
Scala函数式编程
zhongmingyu
03-20 871
3.1 无参，无返回值println("无参，无返回值")test1()3.2 无参，有返回值return "无参，有返回值"3.3 有参，无返回值println(s)3.4 有参，有返回值return s+"有参，有返回值"3.5 多参，无返回值。
Scala 函数式编程
qq_70085330的博客
08-08 385
Scala函数式编程
Scala函数式编程.pdf
05-18
函数式编程（FP）是一种...《Scala函数式编程》是针对希望学习FP并将它应用于日常编码中的程序员而写的，内容包括：函数式编程的概念；函数式编程相关的各种“为什么”和“怎么做”；如何编写多核程序；练习和检测。
scala-examples:函数式编程的代码示例
04-11
Scala是一种强大的多范式编程语言，它融合了面向对象和函数式编程的特性。这个"scala-examples"项目提供了一系列的代码示例，旨在帮助开发者理解如何在实际中运用Scala的函数式编程概念。 首先，让我们深入了解一下...
Scala函数式编程专题--函数思想介绍
08-19
Scala函数式编程专题--函数思想介绍 Scala 函数式编程是近年来备受关注的编程思想，它可以帮助开发者更好地理解和学习编程的相关知识。本文将详细介绍 Scala 函数式编程的相关资料，并讲解函数式编程的思想和优势...
scala的函数式编程（一）
lazy_moon的博客
08-22 5106
目录 引言 将函数作为值 匿名函数 函数的高级用法 将函数作为参数 将函数作为返回值（很重要） 引言 函数是scala中最重要的部分，有人愿意称“函数式scala中的一等公民”。也就是因为函数才使得scala更加简洁、优雅、又耐人寻味，总之，函数式编程在scala中是一等一的重要，使用scala开发的各类框架都存在这大量函数，如果想去了解、阅读Spark源码，函数式编程这一关必须要...
第3讲：Scala函数式编程彻底精通
snail_gesture的博客
02-03 3860
简介： 本篇博文主要是对Scala函数式编程的彻底详解，涉及高阶函数，闭包，颗粒化等详解。 1. Scala函数式编程 Scala中的函数的可以不依赖类或则借口，独立存在，甚至函数可以作为参数传递，可以直接赋值给变量。 Scala的函数式编程使得算法的设计可以更高效更精简，因为函数式是依赖人们的思考 方式构建的。 Scala的函数式编程是的开发代码行数更少。 Sp
scala与函数式编程——从范畴论看函数式编程
samsai100的博客
05-09 1464
什么是范畴？　　其实范畴Category就是指一群事物以及这些事物之间的所有关联关系，这些事物和这些关联关系共同组成了某个范畴。 函数式编程所描绘的范畴，是一个以数据类型为点，以函数为箭头，并且充满了自函子映射的范畴。 从范畴论的角度看函数式编程，会产生一种全新的理解。OO之后人们以构建和封装对象的角度来看待编程，一度使编程与数学脱离。但函数式编程的出现，则重新从数学理论的视角出发，将编程与数学又一次地联系起来
Scala函数式编程【从基础到高级】
m0_64261982的博客
06-23 1354
Scala函数式编程【从基础到高级】
Scala06：Scala的函数式编程
weixin_40612128的博客
03-08 1416
下面我们来学习一下scala中最重要的内容，函数式编程，其实我们学习Scala这门语言就是因为它的这一个特性，咱们在最开始的时候给大家演示了，使用java代码实现函数式编程是很复杂的，而使用scala代码实现函数式编程就很轻松，很简单了。 这块内容我们在后续工作中会经常使用，需要大家重点掌握。 一、什么是函数式编程 Scala是一门既面向对象，又面向过程的语言。 因此在Scala中有非常好的面向对象的特性，可以使用Scala来基于面向对象的思想开发大型复杂的系统和工程； 而且Scala也面向过程，因此Sca
[scala]函数式编程思想入门
越努力越幸运
09-27 2049
1.python闭包的栗子 def make_adder(addend): def adder(augend): return augend + addend return adder p = make_adder(23) q = make_adder(44) print p(100) print q(100)这里比较特殊的就是make_adder是一个函数，
Scala中的函数式编程
热门推荐
周天祥的博客
11-19 7万+
Scala中的函数式编程 Scala程序设计 第2版 - 原版.pdf 下载：https://download.csdn.net/download/u014646662/10805074 作为一门面向对象与函数式的混合范式语言，Scala 并不强制要求函数必须是纯函数，也不要求变量不可变。尽管它的确推荐你在任何可能的情况下这么做。 以下是几个高阶函数，我们将其组合在一起，用它来对一个整数列表...
scala函数式编程pdf
最新发布
06-24
《Scala函数式编程》是一本非常实用的Scala编程书籍，旨在教读者如何使用Scala编程语言实现函数式编程。该书通过具体的实例和案例来阐述Scala函数式编程的核心概念和技术，包括函数式编程基础、函数的高阶抽象、类型...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Aimyon_36

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值