Scala函数的学习
函数的定义
//标准定义函数
//scala语言相对灵活多变
//传入的参数可以是函数,返回值类型也可以是函数(在后面都会说)
//没有返回值的时候可以写Unit也可以不写
def 函数名(参数1:参数类型,参数2:...):返回值类型={ 代码块... }
使用函数时可以指定参数名
//将传入的两个参数合并输出
def showMsg(name:String,age:Int) =println("Hello:"+name+"age:"+age)
//正常使用函数
showMsg("kb09",3)
//指定参数名,顺序没有要求
showMsg(age=3,name="KB09")
函数参数个数不确定
//在参数后加上*号,不确定个数的参数类型需要相同
//输出所有参数
def showMsg2(name:String,s:String*)={println(name) ;for(str<-s) {println(str)}}
//使用函数,
showMsg2("kb09","zhangsan","lisi")
匿名函数
//匿名函数
(a:Int,b:Int)=>a+b
//匿名函数是可以传递的
val aa=(a:Int,b:Int)=>a+b
val bb=aa
//使用匿名函数
println(aa(5,2))
println(bb(5,2))
将函数作为参数类型
//定义函数
def fun(a:Int,b:Int):Int=a+b
def fun1(a:Int,b:Int):Int=a-b
def fun2(a:Int,b:Int):Int=a*b
//将函数作为参数,函数格式为(Int,Int)=>Int
//将值传入函数f,返回的结果与字符串参数合并
def funTest(f:(Int,Int)=>Int,s:String):Unit={
val resultValue=f(1000,2000)
var aa=s+resultValue
println(aa)
}
//将函数fun作为参数
funTest(fun,"zhnagsan")
//将函数fun1作为参数
funTest(fun1,"zhnagsan")
//将函数fun2作为参数
funTest(fun2,"zhnagsan")
将函数作为返回类型
//定义一个没有参数的函数,返回值为函数
def funTest():(String,String)=>String={
//在函数内定义一个函数:将字符串合并
def fun2(str:String,str2:String):String={
str+str2
}
//将函数进行返回
//返回后就会拿到返回函数的参数,执行函数fun2
fun2
}
//使用函数并传入返回函数的参数
//注意:虽然函数funTest没有参数,但括号不能少
println(funTest()("aa","bb"))
多层返回函数
//定义函数test
//功能:判断参数a能否被3整除,在返回函数类型为(Int,Int)=>(String)=>Unit即test1、2内进行进一步的操作
//而test1、2的功能是判断参数和是否大于3000,返回函数类型为(String)=>Unit即test3、4、5、6,内进行进一步的操作
//根据最后的执行到对应的test中执行对应的代码块()
def test(a:Int):(Int,Int)=>(String)=>Unit={
if(a%3==0){
def test1(a:Int,b:Int):(String)=>Unit={
if(a+b>3000){
def test3(name:String):Unit={
println(name+"一号")
}
test3
}else{
def test4(name:String):Unit={
println(name+"二号")
}
test4
}
}
test1
}else{
def test2(a:Int,b:Int):(String)=>Unit={
if(a-b>3000){
def test5(name:String):Unit={
println(name+"三号")
}
test5
}else{
def test6(name:String):Unit={
println(name+"四号")
}
test6
}
}
test2
}
}
//使用多层返回函数,输入每层返回函数所对应的参数
test(3)(1000,3000)("zhangsan")
将函数作为参数以及返回函数
//定义函数test
//参数函数格式为(String)=>Int
//返回函数格式为(Int,Int)=>Int
//函数test实现的功能是:将参数str作为参数传入为函数f,的到结果进行对3的取余,当结果为0是返回第一种匿名函数,否则第二种匿名函数
def test(f:(String)=>Int,str:String):(Int,Int)=>Int={
val a = f(str)
if(a%3==0){
(a:Int,b:Int)=>a+b
}else{
(a:Int,b:Int)=>a-b
}
//使用函数test
//参数函数f的操作是将参数aa进行判断是否为“aaa”,并返回相应的数字
println(test((aa:String)=>{if(aa.equals("aaa")) 3 else 2 },"aaa")(1,3))
部分函数
//定义一个函数,将传入的3个值进行相加
def add(a:Int,b:Int,c:Int): Unit ={
println(a+b+c)
}
//定义一个常量
val title=10
//可以通过定义一个函数,指定常量用在参数,在调用该函数时,只需要传入剩下参数
def showAdd =add(title,_:Int,_:Int)//部分函数
//使用函数调用函数,只传入两个参数,第一个参数为默认值
showAdd(10,10)
偏函数
//偏函数(关键字:PartialFunction)
//示例一
//传入String类型输出Int类型
def funPartional:PartialFunction[String,Int]={
case "hello" => 1
case "world" => 2
case _ => 0
}
//调用函数
println(funPartional("gree")) //输出0
//定义一个list
val worlds=List("hello","world","gree")
//使用collect函数使用偏函数遍历输出结果
worlds.collect(funPartional).foreach(println)
//类语言方式也可以执行(不推荐)
worlds collect funPartional foreach println
//示例二
//偏函数通常可以用来数据清洗
def funGender:PartialFunction[String,Int]={
case "male" => 1
case "female" => 0
case "男" => 1
case "女" => 0
case "F" => 1
case "f" => 0
case "M" => 1
case "m" => 0
case _ => -1
}
val genders=List("男","女","M","f","F","male")
genders.collect(funGender).foreach(println)
//示例三
//传Char类型返回(Char,Int)类型
def funTupple:PartialFunction[Char,(Char,Int)]={
case 'A'=>('A',1)
case 'B'=>('B',1)
case _=>('X',1)
}
//单个调用
//println(funTupple('A'))
val chars=List('A','B','C')
chars.collect(funTupple).foreach(println)
//示例四
//传入类型不定,返回Int类型
//符合Int类型的输出1,不符合的输出0
def fun2:PartialFunction[Any,Int]={
case i:Int=>i
case _ => 0
}
val list=List("a",'c',1,2.5)
//符合Int类型的输出1,不符合的输出0
list.collect(fun2).foreach(println)