Scala常见函数类型，如匿名函数、高阶函数--实例解析

一、匿名函数

在java中我们定义一个函数时是这么写的：

public int funJia(int a,int b){
        int sum = a+b;
        return sum;
    }

funJia 为函数名

在scala中定义一个普通函数的写法：

 def funJia(a:Int,b:Int):Int = {
      var sum = a+b
      return  sum
    }

1.1 定义

两者写法函数名称都为 funJia ，但是在scala中，函数也可以没有名称，即非显式定义一个函数，称为 匿名函数 ，使用匿名函数可以使代码更加简洁、飘逸

1.2 语法

匿名函数语法： (参数名:参数类型) => 函数体
函数体类似于java函数中 {} 的内容
接上例，如：

(a: int,b:int) => a+b

此时可以使用一个变量 result 接收函数返回值，就可以输出打印了

val result = (a: int,b:int) => a+b
println(result(5,3))
//输出结果： 8

定义一个无返回值的匿名函数

val funcSayHello = (name:String) => println("Hello:" +name)
funcSayHello("Kitty")
//输出结果：   Hello:Kitty

二、高阶函数

2.1 定义

java是一种面向对象的语言，而scala既可以面向对象又可以面向函数，是两种方式结合的语言。在scala中，可以把函数当做一个数据类型，像其他数据类型一样被传递和操作。将其他函数作为参数或者使用函数作为输出结果的函数，称为 高阶函数

2.2 示例

2.2.1 定义一个函数：（参数：函数，返回值：String）

定义一个普通函数 funcDemo1 ，传入参数为“函数”和“String”两个类型，返回值类型为 String 类型

//定义加减乘除 四个普通函数
def func1(a:Int,b:Int):Int = a+b  
def func2(a:Int,b:Int):Int = a-b
def func3(a:Int,b:Int):Int = a*b
def func4(a:Int,b:Int):Int = a/b

//再定义一个函数 funcDemo1，传入参数为“函数”和“String”两个类型，返回结果为 String 类型
//此处的函数类型为：(Int,Int)=>Int
def funcDemo1(f:(Int,Int)=>Int,s:String):String={
      var sum:Int = f(200,100)
      return s+sum   //返回值为String类型 s+sum，这里的return关键字可以省略不写
    }
    
//测试：定义str1,2,3,4 四个变量，输出打印
var str1 = funcDemo1(func1,"结果为")
var str2 = funcDemo1(func2,"结果为")
var str3 = funcDemo1(func3,"结果为")
var str4 = funcDemo1(func4,"结果为")
println(str1)
println(str2)
println(str3)
println(str4)

输出结果如下

2.2.2 定义一个函数：（参数：String，返回值：函数）

定义一个普通函数 funcDemo2 ，传入参数类型为 “String”，返回值类型为 “函数”
此处的函数类型为：(String,String) =>String

def funcDemo2(s:String):(String,String) =>String={
    def funcDIY(a:String,b:String):String={   //函数体中内容为自定义一个函数，但是类型与外层返回类型的"函数"一致
     var str:String="输入值："+s+",返回两个值为："+a,b
     return str   //返回一个String类型的结果str，这里的return关键字可以省略不写
    }
    return funcDIY    //返回值为函数类型的值funcDIY，这里的return关键字可以省略不写
  }
//测试：定义一个变量str，输出打印 
//第一个括号("tom")指入参
//第二个括号("eat","drink")指返回值 
var str:String =funcDemo2("tom")("eat","drink")   //此处因为funcDemo2返回类型为"函数"，而此"函数"的返回类型为String，所以使用变量接收funcDemo2的结果，类型也应该为String
println(str)

输入结果如下：

2.2.3 定义一个函数：（参数：函数，返回值：函数）

定义一个普通函数 funcDemo3 ，传入参数类型为 “函数”，返回值类型为 “函数”
此处 入参 的函数类型为：(Int,Int)=>Int
此处 返回 的函数类型为：(String,String) =>String

def funcDemo3(f:(Int,Int)=>Int):(String,String)=>String={
	//函数体中内容如下：
      var sum = f(100,200)   //定义一个变量var，指定入参函数的两Int值为100,200
      def fun1(a:String,b:String):String={   //自定义返回值类型的函数
        a+sum+"，"+b
      }
      fun1   //返回值为函数类型的值 func1
    }
//测试：定义一个变量str，输出打印
//第一个括号((a,b) => {a+b})指入参函数，并且指定函数体为a+b
//第二个括号("你中奖了：","恭喜恭喜")指返回值函数的参数 
var str = funcDemo3((a,b) => {a+b})("你中了","恭喜恭喜")
println(str)    

打印结果如下：

三、递归函数

3.1 定义

递归函数体中，函数本身会自己调用自己的函数

3.2 示例

①：定义一个函数递归相加，实现 "1+2+3+4+5+6…=？"

  def func(num :Int):Int = {
      if (num == 1)
        1
      else
        num + func(num - 1)
    }
    
	//测试
    var result :Int=func(6)  //6+5+4+3+2+1=21
    println(result)
    
	//控制台输出结果：21

②：定义一个函数递归相乘，实现 "123456…=?"

 def func(n: Int): Int = {
      if (n < 1)
        return 0
      else if (n == 1)
        1
      else
        n * func(n - 1)
    }
    
    //测试
    val a = func(5)   //5*4*3*2*1=120
    println(a)
    
    //控制台输出结果：120

四、定义一个函数传递可变长度的参数

在参数类型后面加个 *，可随意传递多个相同类型的参数
例：传递多个String类型的参数

  def funParas(s:String*): Unit={
      for (str <- s){
        println(str)
      }
    }
    
    //测试
    funParas("head","body","foot")
    
    //控制台打印结果：
    //head
    //body
    //foot

五、部分函数

5.1定义

部分函数的逻辑逻辑概念是指调用时缺少部分参数的函数。

5.2示例

//定义一个普通函数，传入三个参数：String,String,Double,打印输出
def showMsg(title:String,content:String,height:Double)={
            println(title+" "+content+":"+height+"m")
          }
//测试 
showMsg("警告","水位超过警戒线",1.0)
//控制台输出结果：警告 水位超过警戒线:1.0m

下面我们来定义一个部分函数：

//首先定义一个常量，标题；“警告”
val title:String="警告"
//定义部分函数showAlert,他的函数体是直接引用直接定义的函数showMsg,将tittle传进来，其余两个参数String、Double使用占位符_ 传入
def showAlert=showMsg(title,_:String,_:Double)

//测试，这时我们在调用showAlert函数时，只需要输入两个参数即可，第一个参数String之前已经传入进来
showAlert("水位超过警戒线",2.0)

//控制台输出结果：警告 水位超过警戒线:2.0m

部分函数的 作用 是： 当在在代码中需要多次调用一个函数函数, 而其中的某个参数又总是相同时, 使用部分函数可以使代码更简洁

六、偏函数

6.1定义

偏函数是指定函数输入输出类型的一种函数 PartialFunction[-T,+V]
有点类似于java中的泛型
偏函数只接受指定类型的参数，并返回指定类型输出

6.2示例

//定义一个函数，判断性别。当输入"male"时返回1，输入"female"时返回0，不能正确识别返回0
def fun:PartialFunction[String,Int] ={
      case "male" => 1
      case "female" => 0
      case _ => -1
    }

//测试： 
println(fun("male"))
println(fun("female"))
println(fun("fasf"))

  //控制台打印结果：
  //1
  //0
  //-1

作用： 如果要筛选信息时，使用偏函数可以起到过滤作用