Scala---基础应用

最小值

    println("-----最小值-----")
    def minValue(a:Int,b:Int):Int = {
      if (a>b) b else a
    }
    println(minValue(3,1))

    def showMsg(name:String,age:Int):String={
      "我的名字："+name+"，年龄："+age
    }
    println(showMsg("KB21",4))

函数10 返回10*9***1(递归)

    println("-----函数10 返回10*9***1(递归)-----")
    def ji(n:Int):Int={
      if (n==1) 1
      else n*ji(n-1)
    }
    println(ji(2))
    println(ji(3))

指定形参名字，传参

    println("-----指定形参名字，传参-----")
    def showMsg2(name:String,age:Int):Unit={
      println("我的名字："+name+"，年龄："+age)
    }

    showMsg2(age = 21,name = "gree")

通过*来传递参数

    println("-----通过*来传递参数-----")
    def showMsg3(name:String,s:String*):Unit={
      println(name)
      println(s.getClass)//映射查看类型
      for(str<-s){
        println(str)
      }
    }
    showMsg3("gree")
    showMsg3("gree","happy","bigdata")

匿名函数

//    匿名函数
//    abc2=abc
    val name : String = "gree"
    val age : Int = 21
    val abc2 : (Int,Int)=>Int = (a:Int,b:Int)=>{
      println("a+b="+(a+b))
      a+b
    }
//    abc为abc2的简化版
    val abc = (a:Int,b:Int) => a+b
    println(abc(10,20))

两数之和

    println("-----两数之和-----")
//    常规版
//    def sum(a:Int,b:Int):Int={
//      a+b
//    }
//    println(sum(10,20))

//    简化版
    def sum(a:Int,b:Int):Int=a+b
    println(sum(10,20))
//

用函数作为参数传递

    println("-----用函数作为参数传递-----")
    def funTest(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
    }
    var resultStr = funTest(f, "张三的工资是：")
    println(resultStr)

判断值是奇偶数 对已知的两个数求和或差

    println("-----判断值是偶数 对已知的两个数求和 是奇数 对已知的两个数求差(动态可变)-----")
    def funTest2(num:Int,f1:(Int,Int)=>Int,f2:(Int,Int)=>Int):Int={
      val value1 = 1000
      val value2 = 2000
      if (num%2==0){
        println("是偶数")
        f1(value1,value2)
      } else {
        println("是奇数")
        f2(value1,value2)
      }
    }
    val f1:(Int,Int)=>Int=(value1:Int,value2:Int)=>{
      println("value1:"+value1+" value2:"+value2)
      value1+value2
    }
    val f2:(Int,Int)=>Int=(value1:Int,value2:Int)=>{
      println("value1:"+value1+" value2:"+value2)
      value1-value2
    }
    var resultStr2 = funTest2(9,f1,f2)
    println(resultStr2)

函数作为函数的返回值返回

    println("-----函数作为函数的返回值返回-----")
    def funTest3(num:Int):(Int,Int)=>Int= {
      println("num value is " + num)

      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 result = funTest3(10)(10, 10)
    println(result)

    val resultFun:(Int,Int)=>Int = funTest3(9)
    val resultValue = resultFun(10,20)
    println(resultValue)

函数作为参数返回函数

    println("-----函数作为参数返回函数-----")
    println("-----传值num1 num2，函数fun1 用fun1计算结果判断是否大于0-----")
    println("-----如果大于0 返回求和函数 如果小于零 返回求积函数-----")
    def funtest4(num1:Int,num2:Int,fun1:(Int,Int)=>Int):(Int,Int)=>Int={
      println("num value1 is " + num1 + " ; num value2 is " + num2)
      def sum(a: Int, b: Int): Int = {
        a + b
      }
      def mul(a: Int, b: Int): Int = {
        a * b
      }
      if (fun1(num1,num2)>0){
        sum
      } else {
        mul
      }
    }

//    def fun1(num1:Int,num2:Int):Int = {num1-num2}
//    val res = funtest4(1,2,fun1)(100,200)
    val res=funtest4(10,12,(a:Int,b:Int)=>a-b)(100,200)
    println(res)

函数柯里化

    println("-----函数柯里化-----")
    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
    }
    def fun5(a:Int)(b:Int,c:String,d:Int):Int={
      println(c)
      a+b+d
    }

    println(fun(1,2,3,4))
    println(fun2(1,2)(3,4))
    println(fun3(1,2,3)(4))
    println(fun4(1)(2)(3)(4))
    val intToIntToIntToInt: Int => Int => Int => Int = fun4(1)
    val i = intToIntToIntToInt(2)(3)(4)
    println(i)

偏函数(字符串转化int)

例一

    println("-----偏函数(字符串转化int)-----")
    def funPartition:PartialFunction[String,Int] = {
      case "Hello"=>1
      case "World"=>2
      case _ =>3
    }
    println(funPartition("cjj"))
    println(funPartition("Hello"))
    println(funPartition("World"))

    val strings = Array("Hello", "java", "World", "hive", "spark")
    val ints:Array[Int] = strings.collect(funPartition)
    for (i<-ints){
      println(i)
    }

 例二

    println("-----偏函数(字符串转化int)-----")
    def funPartition3:PartialFunction[String,Int]={
      case "男"=> 1
      case "女"=> 0
      case "female"=> 0
      case "male"=> 1
      case _=> 2
    }
    println(funPartition3("男"))
    val strings2: Array[String] = Array("男","female","male","女","hello")
    val ints2: Array[Int] = strings2.collect(funPartition3)
    println(ints2.toList)

偏函数(int转化字符串)

    println("-----偏函数(int转化字符串)-----")
    def funPartition2:PartialFunction[Int,String]={
      case 1=>"优秀"
      case 2=>"良好"
      case 3=>"合格"
      case _=>"战五渣"
    }
    println(funPartition2(2))
    val ints1: Array[Int] = Array(1, 4, 5, 2, 6, 7, 2, 1, 3)
    val strings1: Array[String] = ints1.collect(funPartition2)
    println(strings1.toList)

水位警告案例

    def showAlarm(title: String, content: String, height: Double) = {
      println(title + " " + content + " " + height)
    }

    /*  showAlarm("高水位警告","即将超过最高水位线,当前水位",18.8)*/
    val title = "高水位警告"

    def showWaterAlarm = showAlarm(title, _: String, _: Double)

    showWaterAlarm("即将超过最高水位线,当前水位", 18.8)
    val content="即将超过最高水位线,当前水位"
    val content2="即将低于最低水位线,当前水位"
    def showWaterHeightAlarm=showWaterAlarm(content,_:Double)
    showWaterHeightAlarm(18.8)
    def showWaterLowerAlarm=showWaterAlarm(content2,_:Double)
    showWaterLowerAlarm(10)