高阶函数

函数可以作为参数进行传递和返回值进行返回

//传一个a乘b 就返回一个函数，逻辑是实现两数相乘
//传一个a*b 返回一个函数，逻辑是实现两数相乘
//传一个axb 返回一个函数，逻辑是实现两数相乘
def funTest6(str:String,fun:(String)=>Int):(Int,Int)=>Int = {
  val i: Int = fun(str)
  i match {
    case 0 => (a,b)=>a+b
    case 1 => (a,b)=>a-b
    case 2 => (a,b)=>a*b
    case 3 => (a,b)=>a/b
  }
}

val function: (Int, Int) => Int = funTest6("a*b", (s) => {
  if (s.contains("*") || s.contains("乘")) {
    2
  } else {
    0
  }
})

println(function(2, 3))

匿名函数

没有名字的函数就是匿名函数。
例如：

(x:Int)=>{函数体} 
x：表示输入参数类型；Int：表示输入参数类型；函数体：表示具体代码逻辑```
传递匿名函数至简原则：
1.	参数的类型可以省略，会根据形参进行自动的推导
2.	类型省略之后，发现只有一个参数，则圆括号可以省略；其他情况：没有参数和参数超过 1 的永远不能省略圆括号。 
3.	匿名函数如果只有一行，则大括号也可以省略
4.	如果参数只出现一次，则参数省略且后面参数可以用_代替

练习1：传递的函数有一个参数
代码示例：
```Scala
def main(args: Array[String]): Unit = {
 // （1）定义一个函数：参数包含数据和逻辑函数
def operation(arr: Array[Int], op: Int => Int): Array[Int] = {
  for (elem <- arr) yield op(elem)
}
 // （2）定义逻辑函数
 def op(ele: Int): Int = {
 ele + 1
 }
 // （3）标准函数调用
 val arr = operation(Array(1, 2, 3, 4), op)
 println(arr.mkString(","))
 
 
 // （4）采用匿名函数
 val arr1 = operation(Array(1, 2, 3, 4), (ele: Int) => {
 ele + 1
 })
 println(arr1.mkString(","))
 
 
 
 // （4.1）参数的类型可以省略，会根据形参进行自动的推导;
 val arr2 = operation(Array(1, 2, 3, 4), (ele) => {
 ele + 1
 })
 println(arr2.mkString(","))
 
 
 
 // （4.2）类型省略之后，发现只有一个参数，则圆括号可以省略；其他情
况：没有参数和参数超过 1 的永远不能省略圆括号。
 val arr3 = operation(Array(1, 2, 3, 4), ele => {
 ele + 1
 })
 println(arr3.mkString(","))
 
 
 
 // (4.3) 匿名函数如果只有一行，则大括号也可以省略
 val arr4 = operation(Array(1, 2, 3, 4), ele => ele + 1)
 println(arr4.mkString(","))
 //（4.4）如果参数只出现一次，则参数省略且后面参数可以用_代替
 val arr5 = operation(Array(1, 2, 3, 4), _ + 1)
 println(arr5.mkString(","))
 
 } 
}

练习二：传递的函数有两个参数
代码示例：

object TestFunction {
 def main(args: Array[String]): Unit = {
 def calculator(a: Int, b: Int, op: (Int, Int) => Int): Int 
= {
 op(a, b)
 }
 // （1）标准版
 println(calculator(2, 3, (x: Int, y: Int) => {x + y}))
 // （2）如果只有一行，则大括号也可以省略
 println(calculator(2, 3, (x: Int, y: Int) => x + y))
 // （3）参数的类型可以省略，会根据形参进行自动的推导;
 println(calculator(2, 3, (x , y) => x + y))
 // （4）如果参数只出现一次，则参数省略且后面参数可以用_代替
 println(calculator(2, 3, _ + _))
 } 
}

偏函数

偏函数是一个特质 ,用来专门处理某种数据类型! [注意可以同时处理多种数据类型]

偏函数的定义：

val second: PartialFunction[List[Int], Option[Int]] = {
     case x :: y :: _ => Some(y)
}

注：该偏函数的功能是返回输入的 List 集合的第二个元素

案例：将集合中的所有的Int类型的数据都加上1

代码示例：

 //  方式一   过滤器形式
 val list = List(1, 2, 3, 4, "hello")
 val res: List[Int] = list.filter(x => x.isInstanceOf[Int]).map(x => x.asInstanceOf[Int] + 1)
 res.foreach(println)
 
 // 方式二   匹配模式
 val res2: List[Any] = list.map(x => x match {
   case x: Int => x + 1
   case _ =>
   })
 res2.filter(x => x.isInstanceOf[Int]).foreach(println)
 
 // 方式三  使用偏函数  泛型1 输入的数据类型 泛型2 要处理的数据类型
 val pp = new PartialFunction[Any,Int] {
   // 返回true
   override def isDefinedAt(x: Any) = {
     x.isInstanceOf[Int]
   }
   // 执行下一个方法
   override def apply(v1: Any) = {
     v1.asInstanceOf[Int]+1
   }
 }
 
   //  list.map(pp).foreach(println)
  list.collect(pp).foreach(println)

偏函数原理

上述代码会被 scala 编译器翻译成以下代码，与普通函数相比，只是多了一个用于参数检查的函数——isDefinedAt，其返回值类型为 Boolean。

val second = new PartialFunction[List[Int], Option[Int]] {
 //检查输入参数是否合格
 override def isDefinedAt(list: List[Int]): Boolean = list match 
{
 case x :: y :: _ => true
 case