scala支持两种编程范例:面向对象编程( OOP )和函数编程( FP )。 函数式编程在解决问题时,将问题分解成一个一个的步骤,将每个步骤进行封装(函数),通过调用这些封装好的步骤,解决问题。 在 Scala 当中,函数既可以作为函数的参数使用,也可以将函数赋值给一个变量. ,函数的创建不用依赖于类或者对象。
函数基础
如果不写等于号和方法主体,那么方法会被隐式声明为抽象(abstract),包含它的类型于是也是一个抽象类型。
函数和方法的区别
函数在scala语言中,是函数编程的 “头等公民”方法是 scala 面向对象中的概念,主要定义在类,特质,抽象类中函数是一个对象,方法本质就是类中的一个普通的方法函数可以作为参数进行传递,可以作为返回值返回,但是方法不行方法可以通过一定的语法转成函数 参考博文:https://blog.csdn.net/mswuxianshen/article/details/84
def main(args: Array[String]): Unit = {
//定义函数
def sayHi(name:String):Unit = {
println("hi,"+name)
}
//调用函数
sayHi(name ="alice")
//调用对象方法
this.sayHi(NAME="Bob")
}
//定义对象的方法
def sayHi(name:String):Unit = {
println("Hi,"+name)
}
返回值
(1)函数1:无参,无返回值
def f1():Unit ={
println("1.无参,无返回值")
}
//调用
f1()
(2)函数2:无参,有返回值
def f2():Int ={
println("1.无参,有返回值")
return 12
}
//调用
println(f2())//12
(3)函数3:有参,无返回值
def f3(name:String):Unit ={
println("3.有参,无返回值"+name)//输出:有参,无返回值alice
}
println(f3(name="alice" ))//输出:()
(4)函数4:有参,有返回值
def f3(name:String):String ={
println("3.有参,无返回值"+name)//输出:有参,无返回值alice
return "hi,"+name
}
println(f3(name="alice" ))//输出:hi,alice
可变参数
Scala 允许指明函数的最后一个参数可以重复,即我们不需要指定函数参数的个数,可以向函数传入可变长度参数列表。 Scala 通过在参数的类型之后放一个星号来设置可变参数(可重复的参数)。
def f1(str:String*):Unit ={
println(str)
}
f1(str="alice")//WrappedArray(alice)
f1("aaa","bbb","ccc")//WrappedArray(aaa, bbb, ccc)
如果参数列表中存在多个参数,那么可变参数一般放置在最后
def f1(str1:String,str2:String*):Unit ={
println("str1 "+str1+"str2 "+str2)
}
f1(str1="alice")//str1 alicestr2 WrappedArray()
f1("aaa","bbb","ccc")//str1 aaastr2 WrappedArray(bbb, ccc)
参数默认值,一般将有默认值的参数放置在参数列表的后面
def f1(str:String="Heria"):Unit ={
println("My name is "+str)
}
f1("Java")//My name is Java
f1()//My name is Heria
函数至简原则:能省则省
现有原始长度函数
def f0(name:String):String ={
return name
}
println(f0("Heria"))
一、return可以省略,Scala 会使用函数体的最后一行代码作为返回值
def f1(name:String):String ={name}
println(f1("Heria"))
二、如果函数体只有一行代码,可以省略花括号
def f2(name:String):String =name
println(f2("Heria"))
三、返回值类型如果能够推断出来,那么可以省略(:和返回值类型一起省略)
def f3(name:String) =name
println(f3("Heria"))
四、如果有return,则不能省略返回值类型,必须指定 五、如果函数明确声明unit,那么即使函数体中使用return关键字也不起作用 六、Scala如果期望是无返回值类型,可以省略等号
def f6(name:String){
println("Heria")
}
七、如果函数无参,但是声明了参数列表,那么调用时,小括号,可加可不加
def f7():Unit={
println("Heria")
}
f7
八、如果函数没有参数列表,那么小括号可以省略,调用时小括号必须省略
def f8:Unit={
println("Heria")
}
f8
九、如果不关心名称,只关心逻辑处理,那么西数名(def)可以省略
//匿名函数,lambda表达式
(name:String)=>{println(name)}
匿名函数
Scala支持一级函数,函数可以用函数文字语法表达
//匿名函数,lambda表达式
val fun = (name:String)=>{println(name)}
//val stringToUnit: String => Unit = (name:String) => {println(name)}
//以String作为参数,Unit作为返回值的函数
fun("Heria")
匿名函数的主要作用是作为参数参与函数的运行
val fun = (name:String)=>{println(name)}
def f(func:String=>Unit):Unit={
func("Heria")
}
f(fun)
为什么这个函数可以直接打印?因为f函数调用了func这个作为参数的函数,而我们在调用f函数时,是将fun函数作为参数传入的。fun函数需要传入String类型的参数,func("Heria")将Heria作为参数传入。 f()这种类型的函数的目的是为了针对固定的数据,传入不同的函数对数据进行操作 匿名函数的简化原则
f((name:String)=>{println(name)})
一、参数的类型可以省略,会根据形参进行自动的推导
f((name)=>{
println(name)
})
二、类型省略之后,发现只有一个参数,则圆括号可以省略;没有参数和参数超过一的永远不能省略括号。
f(name=>{
println(name)
})
三、匿名函数如果只有一行,则大括号也可以省略
f(name=>
println(name))
四、如果参数只出现一次,则参数省略且后面参数可以用_代替
f(println(_))
五、如果可以推断出,当前传入的println是一个函数体,而不是调用语句,可以直接省略下划线
f(println)
案例实操1 定义一个”二元运算函数,只操作1和2两个数,但是具体运算通过参数传入
def dualFunctionOneAndTwo(fun:(Int,Int)=>Int):Int={
fun(1,2)
}
//1
val add =(a:Int,b:Int)=>a+b
println(dualFunctionOneAndTwo(add)
//2
println(dualFunctionOneAndTwo((a:Int,b:Int)=>a+b))
//3
println(dualFunctionOneAndTwo((a,b)=>a+b))
//4
println(dualFunctionOneAndTwo(_+_))
案例实操2 定义一个函数func,它接收一个Int类型的参数,返回一个函数(记作fl1)。 它返回的函数f1,接收一个string类型的参数,同样返回一个函数(记作2)。函数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'))//false
简化后
def func(i: Int): String=>(Char=>Boolean) = {
s=>c=>if (i == 0 && s == "" && c == '0') false else true
}
println(func(0)("")('0'))//false
柯里化
def func(i:Int)(s:String)(c:Char):Boolean={
if(i==0 && s=="" && c=="0") false else true
}
高阶函数
高阶函数将其他函数作为参数或其结果是函数的函数。
一、函数作为值进行传递
def f(n:Int):Int={
println("f调用")
n+1
}
//val f1:Int=>Int=f
val f2 =f _
二、函数作为参数进行传递
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,1,2))
println(dualEval((a,b)=>a+b,1,2))
println(dualEval(_+_,1,2))
三、函数作为返回值返回
def f5(): Int=>Unit = {
def f6(a: Int): Unit = {
println("f6调用" +a)}
f6 //将函数直接返回
}
//println(f5())//返回引用
val f6 =f5()
println(f6)//输出:
println(f6(25))
//输出:f6调用25
// ()
println(f5()(25))
//输出:f6调用25
// ()
案例实操 对数组进行处理,将操作抽象出来,处理完毕之后的结果返回一个新的数组
val arr: Array [Int] = Array(12,45,75,98)
def array0peration(array: Array[Int],op: Int=>Int): Array[Int] = {
for (elem <- array) yield op(elem)
}
//定义一个加一操作
def add0ne(elem: Int): Int = {
elem + 1
}
//调用函数
val newArray: Array[Int] =array0peration(arr,add0ne)
println(newArray.mkString(" , "))//13 , 46 , 76 , 99
柯里化函数
以匿名函数案例实操2为例,原代码为
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
}
该代码实现了函数的嵌套,func的返回值是f1,f1返回值是f2,f2返回的是基于条件判断的布尔类型的值。输出时以println(func(0)("")('0'))为例,调用func函数,传入参数0,得到(Char=>Boolean)函数返回值,相当于得到了f1的调用,此时,func的调用已经结束。i作为具备变量已经释放掉,最终在f2中,在语言理解层面是没办法取到i去做条件判断。 **闭包:**能够读取其他函数内部变量的函数。在本质上,闭包是将函数内部和函数外部连接起来的桥梁。 scala在调用函数时,创建一个对象实例,放到堆内存中。这个对象实例中打包了相关环境和局部变量。 案例实操 期望进行两树相加的操作,其中一个数我们希望固定好,但是熬以参数形式传入 变更前
def addBy4():Int=>Int={
val a = 4
def add(b:Int):Int={
a+b
}
add
}
变更后
def addByA():Int=>Int={
val a = 4
def add(b:Int):Int={
a+b
}
add
}
println(addByA(35)(24))
val addByFour=addByA(4)
printlnaddByFour(12)
lamda表达式简化
def addByA(a:Int):Int=>Int = a + _
柯里化(Currying)函数是一个带有多个参数,并引入到一个函数链中的函数,每个函数都使用一个参数。函数柯里化的过程是把一个参数列表的多个参数,变成多个参数列表。
def addCurrying(a:Int)(b:Int):Int={
a+b
}
println(addCurrying(35)(24))
递归
一个函数/方法体内又调用了自身称为递归调用。 阶乘案例
// 1.循环实现
def circle(n: Int) = {
var result = 1
for (i <- 1 to n) {
result *= i
}
result
}
//2.递归实现
def fact(n: Int):Int ={
return fact(n-1)*n
}
上述递归实现虽然能够极大简化程序员编写代码的量,但是对计算机并不友好。return()会先拿到fact(n-1)的值,再将n与之相乘。当调用下一层函数时,内存仍保存有上一层的数据,极大增加了内存的消耗。为了解决这个问题,引入尾递归的概念,即指在一个方法内部,递归调用后直接return,没有任何多余的指令了。尾递归将外层方法的结果传递给了内层方法,当编译器检测到一个函数调用是尾递归的时候,它就覆盖当前的活动记录而不是在栈中去创建一个新的。这样在计算fact(4)时,会先将fact(5)弹栈,再将fact(4)压栈,保证同时只有一个栈帧在栈里存活
def tailFact(n: Int):Int ={
@tailrec
def loop(n:Int,currRes:Int):Int={
if(n == 0) return currRes
loop(n-1,currRes*n)
}
loop(n,1)
}
传值参数和传名参数
传值参数
如下案例所示,定义一个Int类型的参数,调用这个参数的时候就把Int类型的值传给它,相当于变量赋值。
scala
def f0(a: Int): Unit = {
println("a: " + a)
println("a: " + a)
}
f0(23)
传名参数
将一部分代码或代码块作为整体传递给参数,这个过程也叫名调用。
def x():Int={
println("x调用")
12
}
def f1(a: =>Int): Unit = {
println("a: " + a)
println("a: " + a)
}
f1(x())
传名参数的这种调用方式是将a全部替换成x()代码块 案例实操:自定义while循环 常规的while循环
var n: Int = 5
while (n >= 1) {
println(n)
n -= 1
}
用闭包实现一个函数,将代码块作为参数传入,递归调用
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
}
}
用匿名函数实现
def mywhile(condition: =>Boolean): (=>Unit)=>Unit = {
//内层函数需要递归调用,参数就是符环体
op=> {
if (condition) {
op
mywhile(condition)(op)
}
}
n=10
mywhile(n>=1){
println(n)
n-=1
}
柯里化实现
def mywhile(condition: =>Boolean)(op: => Unit):Unit = {
if (condition) {
op
mywhile(condition)(op)
}
}
n=10
mywhile(n>=1){
println(n)
n-=1
}
惰性加载
当函数返回值被声明为lazy时,函数的执行将被推迟,直到我们首次对此取值,该函 数才会执行。这种函数我们称之为惰性函数。 案例实操
lazy val result:Int=sum(13,47)
println("1.函数调用")
println("1.result="+result)
}
def sum(a:Int,b:Int):Int={
println("3.sum调用")
a+b
//结果
//1.函数调用
//3.sum调用
//2.result=60
lazy使sum(13,47)的求值过程变成了懒加载的过程,当前的result变量可以认为是传名参数,只有在第一次调用的时候才会执行(只调用一次sum函数)
推荐阅读
发表评论