Scala部分函数和偏函数

部分函数

部分函数在调用时，有默认的值，我们只需要赋予其他未设置的值即可。

object Demon {
    def main(args: Array[String]): Unit = {
      //部分函数
      def Stu(grade:Int,name:String,age:Int)={
        println(s"$grade,$name,$age")
      }
      //设置一个默认值 grade
      val level=1
      //其他参数用_:数据类型  替代
      def stuInfo=Stu(level,_:String,_:Int)
      stuInfo("sam",15)
    }
}

再举个例子：

def funAdd(a:Int,b:Int,c:Int)={
        a+b+c
      }
      val a=10
      def Add:(Int,Int)=>Int= funAdd(a, _: Int, _: Int)
      println(Add(1, 2))

在编写代码的时候，我们可以把Add:(Int,Int)=>Int中的(Int,Int)=>Int省略.

偏函数

偏函数只接收和处理定义域范围内的参数，对于参数范围外的参数则抛出异常。
定义偏函数的关键字是:PartialFunction[A,B]
A为输入的数据类型，B为输出的数据类型。用法类似于模式匹配。

object Partial {
  def main(args: Array[String]): Unit = {
    def fun:PartialFunction[String,Int]={
      case "A"=>1
      case "B"=>2
      case "C"=>3
      case _=>0
    }
    println(fun("A"))
  }
}

当我们需要处理一整个数组或集合的时候，可以结合collect函数来使用。

val list=List("A","B","C","D")
    list.collect(fun).foreach(println)

遍历输出结果

当然，返回值除了可以设置成基本数据类型外，还可以设置成其他的类型。
返回一个元组：

def funTuple:PartialFunction[Char,(Char,Int)]={
      case 'A'=>('A',1)
      case 'B'=>('B',2)
      case _=>('X',0)
    }
    var chars=Array('A','B','C','D')
    chars.collect(funTuple).foreach(println)

改变输出方式：

val tuples = chars.collect(funTuple)
	//把输出结果通过字符串分割
    println(tuples.mkString(","))
    println("===========================")
    //打印元组的元素
    tuples.foreach(x=>{println(x._1,x._2)})

如果不确定输入或者输出的类型，那么我们可以设置成Any：

def funTuple:PartialFunction[Char,Any]={
      case 'A'=>('A',1)
      case 'B'=>2
      case _=>"other"
    }
    var chars=Array('A','B','C','D')
    chars.collect(funTuple).foreach(println)