Scala高阶函数

Scala函数的学习

函数的定义

//标准定义函数
//scala语言相对灵活多变
//传入的参数可以是函数，返回值类型也可以是函数(在后面都会说)
//没有返回值的时候可以写Unit也可以不写
def 函数名(参数1:参数类型,参数2：...):返回值类型={ 代码块... }

使用函数时可以指定参数名

//将传入的两个参数合并输出
def showMsg(name:String,age:Int) =println("Hello:"+name+"age:"+age)
//正常使用函数
showMsg("kb09",3)
//指定参数名，顺序没有要求
showMsg(age=3,name="KB09")

函数参数个数不确定

//在参数后加上*号，不确定个数的参数类型需要相同
//输出所有参数
def showMsg2(name:String,s:String*)={println(name) ;for(str<-s) {println(str)}}
//使用函数，
showMsg2("kb09","zhangsan","lisi")

匿名函数

//匿名函数
(a:Int,b:Int)=>a+b
//匿名函数是可以传递的
val aa=(a:Int,b:Int)=>a+b
val bb=aa
//使用匿名函数
println(aa(5,2))
println(bb(5,2))

将函数作为参数类型

//定义函数
def fun(a:Int,b:Int):Int=a+b
def fun1(a:Int,b:Int):Int=a-b
def fun2(a:Int,b:Int):Int=a*b

//将函数作为参数，函数格式为(Int,Int)=>Int
//将值传入函数f，返回的结果与字符串参数合并
def funTest(f:(Int,Int)=>Int,s:String):Unit={
   val resultValue=f(1000,2000)
   var aa=s+resultValue
   println(aa)
}

//将函数fun作为参数
funTest(fun,"zhnagsan")
//将函数fun1作为参数
funTest(fun1,"zhnagsan")
//将函数fun2作为参数
funTest(fun2,"zhnagsan")

将函数作为返回类型

//定义一个没有参数的函数，返回值为函数
def funTest():(String,String)=>String={
   //在函数内定义一个函数：将字符串合并
   def fun2(str:String,str2:String):String={
        str+str2
   }
   //将函数进行返回
   //返回后就会拿到返回函数的参数，执行函数fun2
   fun2
}
//使用函数并传入返回函数的参数
//注意：虽然函数funTest没有参数，但括号不能少
println(funTest()("aa","bb"))

多层返回函数

//定义函数test
//功能：判断参数a能否被3整除，在返回函数类型为(Int,Int)=>(String)=>Unit即test1、2内进行进一步的操作
//而test1、2的功能是判断参数和是否大于3000，返回函数类型为(String)=>Unit即test3、4、5、6，内进行进一步的操作
//根据最后的执行到对应的test中执行对应的代码块()
def test(a:Int):(Int,Int)=>(String)=>Unit={
      if(a%3==0){
        def test1(a:Int,b:Int):(String)=>Unit={
          if(a+b>3000){
            def test3(name:String):Unit={
              println(name+"一号")
            }
            test3
          }else{
            def test4(name:String):Unit={
              println(name+"二号")
            }
            test4
          }
        }
        test1

      }else{
        def test2(a:Int,b:Int):(String)=>Unit={
          if(a-b>3000){
            def test5(name:String):Unit={
              println(name+"三号")
            }
            test5
          }else{
            def test6(name:String):Unit={
              println(name+"四号")
            }
            test6
          }
        }
        test2
      }
    }
//使用多层返回函数,输入每层返回函数所对应的参数
test(3)(1000,3000)("zhangsan")

将函数作为参数以及返回函数

//定义函数test
//参数函数格式为(String)=>Int
//返回函数格式为(Int,Int)=>Int
//函数test实现的功能是：将参数str作为参数传入为函数f，的到结果进行对3的取余，当结果为0是返回第一种匿名函数，否则第二种匿名函数
def test(f:(String)=>Int,str:String):(Int,Int)=>Int={
      val a = f(str)
      if(a%3==0){
        (a:Int,b:Int)=>a+b
      }else{
        (a:Int,b:Int)=>a-b
      }

//使用函数test
//参数函数f的操作是将参数aa进行判断是否为“aaa”,并返回相应的数字
println(test((aa:String)=>{if(aa.equals("aaa")) 3 else 2 },"aaa")(1,3))

部分函数

//定义一个函数，将传入的3个值进行相加
def add(a:Int,b:Int,c:Int): Unit ={
      println(a+b+c)
    }
//定义一个常量 
val title=10

//可以通过定义一个函数，指定常量用在参数，在调用该函数时，只需要传入剩下参数
def showAdd =add(title,_:Int,_:Int)//部分函数
//使用函数调用函数，只传入两个参数，第一个参数为默认值   
showAdd(10,10)

偏函数

//偏函数(关键字：PartialFunction)
//示例一
//传入String类型输出Int类型
	def funPartional:PartialFunction[String,Int]={
      case "hello" => 1
      case "world" => 2
      case  _ => 0
    }
    //调用函数
    println(funPartional("gree")) //输出0
	
	//定义一个list
    val worlds=List("hello","world","gree")
	
    //使用collect函数使用偏函数遍历输出结果
    worlds.collect(funPartional).foreach(println)
	
    //类语言方式也可以执行(不推荐)
    worlds collect funPartional foreach println

//示例二
//偏函数通常可以用来数据清洗
    def funGender:PartialFunction[String,Int]={
      case "male" => 1
      case "female" => 0
      case "男" => 1
      case "女" => 0
      case "F" => 1
      case "f" => 0
      case "M" => 1
      case "m" => 0
      case _ => -1
    }

    val genders=List("男","女","M","f","F","male")
    genders.collect(funGender).foreach(println)

//示例三
//传Char类型返回（Char,Int）类型
    def funTupple:PartialFunction[Char,(Char,Int)]={
      case 'A'=>('A',1)
      case 'B'=>('B',1)
      case _=>('X',1)
    }
    //单个调用
    //println(funTupple('A'))
    val chars=List('A','B','C')
    chars.collect(funTupple).foreach(println)

//示例四
//传入类型不定，返回Int类型
//符合Int类型的输出1，不符合的输出0
    def fun2:PartialFunction[Any,Int]={
      case i:Int=>i
      case _ => 0
    }
    val list=List("a",'c',1,2.5)
    //符合Int类型的输出1，不符合的输出0
    list.collect(fun2).foreach(println)