scala一些函数
1，匿名函数（lambda)：没有名字的函数就是匿名函数，可以通过函数表达式来设置匿名函数
val test: (Int, Int) => Int = (a: Int, b: Int) => {
println("a+b=" + (a + b))
a + b
}2，用函数作为参数传递
def Test(f: (Int, Int) => Int, msg: String): String = {
val a = 100
val b = 200
val result = f(a, b)
msg + result
}
val f: (Int, Int) => Int = (a: Int, b: Int) => {
println("a value:" + a + ",b value:" + b)
a * b
}
val str = funTest(f, "张三的工资是：")
println(str)
//a value:100,b value:200
//张三的工资是：200003,定一个方法，返回值是函数
def Test(num: Int): (Int, Int) => Int = {
println("num value:" + num) //num value:9
def sum(a: Int, b: Int): Int = {
a + b
}
def sub(a: Int, b: Int): Int = {
a - b
}
if (num % 2 == 0) sum else sub
}
//方法一
val i = Test(9)(10, 10)
println(i) //0
//方法二
val iFun: (Int, Int) => Int = Test(9)
val iValue = iFun(10, 20)
println(iValue) //-104，函数柯里化
又称部分求值，将一个函数从可调用的 f(a, b, c) 转换为可调用的 f(a)(b)(c)或者f(a, b)(c)或者f(a)(b, c)
注：柯里化不会调用函数。它只是对函数进行转换
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
}
def fun4(a: Int)(b: Int)(c: Int)(d: Int): Int = {
a + b + c + d
}
println(fun(1, 2, 3, 4))
println(fun2(1, 2)(3, 4))
println(fun3(1, 2, 3)(4)) //结果都是105，偏函数
对给定的输入参数类型，函数可接受该类型的任何值。换句话说，一个(Int) => String 的函数可以接收任意Int值，并返回一个字符串。
对给定的输入参数类型，偏函数只能接受该类型的某些特定的值。一个定义为(Int) => String 的偏函数可能不能接受所有Int值为输入
//偏函数:string进,int出
def funPartition: PartialFunction[String, Int] = {
case "hello" => 1
case "world" => 2
case _ => 3
}
val strings = Array("hello", "java", "world", "hive", "spark")
val ints = strings.collect(funPartition)
for (i <- ints) {
println(i)
}
//1 3 2 3 3
//偏函数:string出,int进
def funPart2:PartialFunction[Int,String]={
case 1 =>"优秀"
case 2 =>"良好"
case 3 =>"合格"
case _ =>"战五渣"
}
val ints1 = Array(1, 5, 4, 6, 8, 6, 7)
val string: Array[String] = ints1.collect(funPart2)
println(string.toList)
//List(优秀, 战五渣, 战五渣, 战五渣, 战五渣, 战五渣, 战五渣)6，部分函数
def showAlarm(title:String,content:String,height:Double)={
println(title+" "+content+" "+height)
}
//showAlarm("高水位警告","即将超过最高水位线，当前水位：",18.56)
val title="高水位警告"
def showWaterAlarm=showAlarm(title,_:String,_:Double)
showWaterAlarm("即将超过最高水位线，当前水位：",18.56)
val content="即将超过最高水位线，当前水位："
val content2="即将到达最低水位线，当前水位："
def showWaterHeightAlarm=showWaterAlarm(content,_:Double)
def showWaterLowerAlarm=showWaterAlarm(content2,_:Double)
showWaterHeightAlarm(18.56)
showWaterLowerAlarm(8.02)
/*
高水位警告 即将超过最高水位线，当前水位： 18.56
高水位警告 即将超过最高水位线，当前水位： 18.56
高水位警告 即将到达最低水位线，当前水位： 8.02
*/7，隐式函数
隐式转换可以在不需改任何代码的情况下，扩展某个类的功能。
//string 转成 int
implicit def stringToInt(value: String): Int = Integer.parseInt(value)
val a: Int = "111";
def main(args: Array[String]): Unit = {
println(a+4) //115 表示a已经转换成int类型
}
----------------------------------------------------------
//int 转成 string
implicit def intToString(value:Int):String={
println(value.getClass+" "+value) //int 10
value.toString
}
val s:String=10
def main(args: Array[String]): Unit = {
println(s+10) //1010 表示s已经传换成string类型
println(s+"dgsgsd") //10dgsgsd 同上
}
-----------------------------------------------------------
//double转成string，并加500
implicit def doubleToString(value:Double):String={
var v1=value+500
v1.toString
}
def main(args: Array[String]): Unit = {
val doubString:String=12800.98
println(doubString); //13300.98是string类型
}方法传值 > 隐式传值 > 默认值
一，方法传值举例
implicit val num:Int=11
implicit val gender:String="male" //---隐式值
def sum(a:Int)( implicit name:String="aaa",b:Int=13):Int={ //---默认值
println(gender)
a+b
}
println(sum (10)("female",10)) //--方法传值
//以上结果为female 20
------------------------------------------------------------------------
二，隐式传值举例
println(sum(10)) //结果是male 21
------------------------------------------------------------------------
三，默认值举例
不要隐式值，再运行结果是aaa 23