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 = 100val b = 200val 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
//张三的工资是：20000

3,定一个方法，返回值是函数

def Test(num: Int): (Int, Int) => Int = {println("num value:" + num)                 //num value:9def 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)                                //-10

4，函数柯里化

又称部分求值，将一个函数从可调用的 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))  //结果都是10

5，偏函数

对给定的输入参数类型，函数可接受该类型的任何值。换句话说，一个(Int) => String 的函数可以接收任意Int值，并返回一个字符串。
对给定的输入参数类型，偏函数只能接受该类型的某些特定的值。一个定义为(Int) => String 的偏函数可能不能接受所有Int值为输入

//偏函数:string进,int出
def funPartition: PartialFunction[String, Int] = {case "hello" => 1case "world" => 2case _ => 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 10value.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+500v1.toString}
def main(args: Array[String]): Unit = {val doubString:String=12800.98println(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