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
//张三的工资是：20000

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

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)                                //-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" => 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