Scala---函数
文章目录
- 一、普通函数
- 二、匿名函数
- 三、递归函数
- 四、高阶函数
- 五、柯里化
- 六、隐式转化
- 七、偏函数
- 八、部分函数
- 九、模式匹配
一、普通函数
def showMe(name:String,age:Int):String={
"my name is "+name+"\tage is "+age
}
val sho = showMe("Tom",34) //按照顺序---传参
println(sho)
val sho1= showMe(age=12,name="hel") //指定形参名---传参
println(sho1)
【注意：函数中只有一条语句可以省略{}】
def sum(a:Int,b:Int):Int = a+b //普通函数 --- 函数中只有一条语句可以省略{}
println(sum(3,-2))
1、比较两个数大小
def minValue(a:Int,b:Int):Int={
if(a>b) a else b
}
val result = minValue(12,34)
println(result)
2、可变长度参数
可变长度的参数，将值放入到Vector集合中
// 可变长度参数,装在一个Array中
def getMe(name:String,s:String*):Unit={
println(name)
for(str<- s){
println(str)
}
}
getMe("To","ss","gg")
二、匿名函数
val x = (a:Int,b:Int)=>a+b //匿名函数
val asd : (Int,Int)=>Int = (a:Int,b:Int)=>a+b //匿名函数加上声明
val asd2 : (Int,Int)=>Int = sum //调用已定义的函数
println(x(10,9)) //调用
println(asd(10,9))
三、递归函数
// 递归 --- 阶层
def Jiecen(x:Int):Int={
if(x==1 || x==0) //定义递归结束
1
else{
x*Jiecen(x-1)
}
}
val ss = Jiecen(0)
println(ss)
四、高阶函数
函数作为参数或者输出
1、函数作为参数
def funtest(f:(Int,Int)=>Int,mess:String):String={ //函数传递函数
val a=90
val b=78
f(a,b)+mess
}
val s= funtest((a,b)=> a+b ,"和") //调用时，直接在实参中定义匿名函数
val s1= funtest((a,b)=> a*b ,"积")
println(s)
2、函数作为返回值
def funTest2():(String,String)=>String={ //函数返回值是个函数
(a:String,b:String)=>a+b
}
println(funTest2()("sc","ge"))
3、函数作为参数和返回值
def f1(a:Int,b:Int,func:(Int,Int)=>Int):(Int,Int)=>Int={
if(func(a,b)%2==0){
(m1,m2)=>m1+m2
}else{
(m1,m2)=>m1-m2
}
}
println(f1(2,3,(a,b)=>a*b)(45,23))
五、柯里化
将多个参数分开赋值
方法可以定义多个参数列表，当使用较少的参数列表调用多参数列表的方法时，会产生一个新的函数，该函数接收剩余的参数列表作为其参数。这被称为柯里化
def fun(a:Int,b:Int,c:Int,d:Int):Int={
a+b+c+d
}
def fun2(a:Int,b:Int)(c:Int,d:Int):Int={
a+b+c+d
}
def fun3(a:Int)(b:Int)(c:Int)(d:Int):Int={
a+b+c+d
}
println(fun(3,4,5,6))
println(fun2(2,3)(3,4))
println(fun3(2)(3)(4)(5))
六、隐式转化
关键字：implicit
- 隐式参数
- 隐式函数
- 隐式类
隐式参数
方法可以具有隐式参数列表，由参数列表开头的implicit 关键字标记
多于柯里化同时使用
// 隐式转换调用方法时 --- 优先级：实参 > 隐式（本类 > 其他类） > 默认
implicit val num:Int = 10 //一个作用域内只能有一个相同类型的隐式参数
implicit val na :String = "Tom"
def sum(a:Int)(implicit b:Int=5,name:String):Int={ //隐式参数，注意看柯里化
println(name)
a+b
}
println(sum(20))
println(sum(20)(20,"Jack"))
println(sum(20)(name ="",b = 3))
隐式函数
implicit def DoubleToInt(value:Double):Int=value.toInt
val a:Int = 34.2 //正常这么定义会报错，但是定义了上面的隐式函数，就可以默认转成对应的类型
println(a)
隐式类
用implicit关键字修饰的类，其主构造器可用于隐式转换
只能在类、Trait、对象（单例对象、包对象）内部定义
构造器只能携带一个非隐式参数
隐式类不能是case class
在同一作用域内，不能有任何方法、成员或对象与隐式类同名
object Implicteg {
implicit class NumberOper(demo1: Demo1){
def sum(a:Int,b:Int):Int={
println("a ="+a+"\tb = "+b)
a+b
}
}
implicit class NumOper2(demo1: Demo1){
def sub(a:Int,b:Int):Int={
println("a = "+a+"\tb="+b)
a-b
}
}
}
import Implicteg._
class Demo1{}
object Demo1 {
def main(args: Array[String]): Unit = {
println(new Demo1().sum(2,4)) //本类中没有定义该方法，就可以通过隐式类获取之
println(new Demo1().sub(4,2))
}
}
七、偏函数
偏函数是只对函数定义域的一个子集进行定义的函数
PartialFunction[-A,+B]是一个特质
// 偏函数 --- 类似于 Java 中的 switch case,只不过Java中的不支持String类型
def funPartition:PartialFunction[String,Int]={ //输入为String,
case "hello"=> 1
case "world"=> 2
case _=>3
}
val i = funPartition("hello")
println(i)
def funPartition2:PartialFunction[Int,String]={
case 1 => "优秀"
case 2 => "良好"
case 3 => "及格"
case _=> "不行啊"
}
println(funPartition2(4))
def sexpartialFunction: PartialFunction[String,Int]={
case "male" |"男"=> 1
case "female" | "女"=> 0
case _=> 9999
}
println(sexpartialFunction("男"))
var arr=Array(1,2,3)
for(x<- arr){
println(funPartition2(x))
}
val strs:Array[String] = arr.collect(funPartition2)
八、部分函数
def sumResult(a:Int,b:Int):Int= a+b
val num1 = 7
def sum=sumResult(num1,_:Int) //部分值传入，注意：类型别忘了加
println(sum(3)) //只写未传入的参数
def showMes(title:String,content:String,height:Double)={
println(title+" "+content+" "+height)
}
showMes("警告","当前水位高",34.3)
val title:String = "警告"
def showAlarm=showMes(title,_:String,_:Double)
九、模式匹配
match 类似于Java中的 switch,但支持所有类型
不需要 break
能够生成返回值
_ :代表默认值
//模式匹配
def match1(x:Int):String= x match {
case 1 => "one"
case 2 => "two"
case _ => "many"
}
def match2(x:Any):Unit = x match {
case 1 => println("内容为1")
case x:Int => println("类型为Int,值为 "+x) //...
case _ => println("无效内容")
}