高階函式

函式可以作為引數進行傳遞和回傳值進行回傳

//傳一個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 _ => false
 }
 //執行函式邏輯
 override def apply(list: List[Int]): Option[Int] = list match 
{
 case x :: y :: _ => Some(y)
 }
}

偏函式的執行流程

遍歷list中的每個元素
呼叫 val e = if (isDefinedAt) {apply}
每得到一個e 就會將e存盤在一個新的集合中回傳使用偏函式就不要使用map方法了

偏函式的簡寫形式

val list = List(2, 4, 6, 8, "cat")

//定義一個偏函式
def myPartialFunction: PartialFunction[Any, Int] = {
  case x: Int => x * x
}
list.collect(myPartialFunction).foreach(println)
// 簡寫方式 
list.collect({
  case x:Int=>x*x
}).foreach(println)

偏函式總結

使用構建特質的實作類(使用的方式是PartialFunction的匿名子類)
PartialFunction 是個特質(看原始碼)
構建偏函式時，引數形式 [Any, Int]是泛型，第一個表示引數型別，第二個表示回傳引數
當使用偏函式時，會遍歷集合的所有元素，編譯器執行流程時先執行isDefinedAt()如果為true ,就會執行 apply, 構建一個新的Int 物件回傳
執行isDefinedAt() 為false 就過濾掉這個元素，即不構建新的Int物件.
map函式不支持偏函式，因為map底層的機制就是所有回圈遍歷，無法過濾處理原來集合的元素
collect函式支持偏函式

模式匹配

模式匹配語法中，采用 match 關鍵字宣告，每個分支采用 case 關鍵字進行宣告，當需要匹配時，會從第一個 case 分支開始，如果匹配成功，那么執行對應的邏輯代碼，如果匹配不成功，繼續執行下一個分支進行判斷，如果所有 case 都不匹配，那么會執行 case _分支，類似于 Java 中 default 陳述句，

基本語法

object TestMatchCase {
 def main(args: Array[String]): Unit = {
 var a: Int = 10
 var b: Int = 20
 var operator: Char = 'd'
 var result = operator match {
 case '+' => a + b
 case '-' => a - b
 case '*' => a * b
 case '/' => a / b
 case _ => "illegal"
  }
 println(result)
 }
}

說明：

如果所有 case 都不匹配，那么會執行 case _ 分支，類似于 Java 中 default 陳述句，若此時沒有 case _ 分支，那么會拋出 MatchError，
每個 case 中，不需要使用 break 陳述句，自動中斷 case，
match case 陳述句可以匹配任何型別，而不只是字面量，
=> 后面的代碼塊，直到下一個 case 陳述句之前的代碼是作為一個整體執行，可以使用{}括起來，也可以不括，

模式守衛

如果想要表達匹配某個范圍的資料，就需要在模式匹配中增加條件守衛，
代碼演示：

object TestMatchGuard {
 def main(args: Array[String]): Unit = {
 def abs(x: Int) = x match {
 case i: Int if i >= 0 => i
 case j: Int if j < 0 => -j
 case _ => "type illegal"
 }
 println(abs(-5))
 } 
}

模式匹配型別

匹配常量

Scala 中，模式匹配可以匹配所有的字面量，包括字串，字符，數字，布林值等等
代碼演示：

object TestMatchVal {
 def main(args: Array[String]): Unit = {
 println(describe(6))
 }
 def describe(x: Any) = x match {
 case 5 => "Int five"
 case "hello" => "String hello"
 case true => "Boolean true"
 case '+' => "Char +"
 }
}

匹配型別

需要進行型別判斷時，可以使用前文所學的 isInstanceOf[T]和 asInstanceOf[T]，也可使用模式匹配實作同樣的功能，
代碼實作：

object TestMatchClass {
 def describe(x: Any) = x match {
 case i: Int => "Int"
 case s: String => "String hello"
 case m: List[_] => "List"
 case c: Array[Int] => "Array[Int]"
 case someThing => "something else " + someThing
 }
 def main(args: Array[String]): Unit = {
    println(describe(List(1, 2, 3, 4, 5)))
    println(describe(Array(1, 2, 3, 4, 5, 6)))
    println(describe(Array("abc")))
 }
}

匹配陣列

scala 模式匹配可以對集合進行精確的匹配，例如匹配只有兩個元素的、且第一個元素為 0 的陣列
代碼實作：

object TestMatchArray {
 def main(args: Array[String]): Unit = {
 for (arr <- Array(Array(0), Array(1, 0), Array(0, 1, 0), 
Array(1, 1, 0), Array(1, 1, 0, 1), Array("hello", 90))) { // 對
一個陣列集合進行遍歷
 val result = arr match {
 case Array(0) => "0" //匹配 Array(0) 這個陣列
 case Array(x, y) => x + "," + y //匹配有兩個元素的陣列，然后將將元素值賦給對應的 x,y
 case Array(0, _*) => "以 0 開頭的陣列" //匹配以 0 開頭和
陣列
 case _ => "something else"
 }
 println("result = " + result)
 }
 }

匹配串列

方式一代碼實作：

object TestMatchList {
 def main(args: Array[String]): Unit = {
 //list 是一個存放 List 集合的陣列
 //請思考，如果要匹配 List(88) 這樣的只含有一個元素的串列,并原值回傳.應該怎么寫
 for (list <- Array(List(0), List(1, 0), List(0, 0, 0), List(1, 
0, 0), List(88))) {
 val result = list match {
 case List(0) => "0" //匹配 List(0)
 case List(x, y) => x + "," + y //匹配有兩個元素的 List
 case List(0, _*) => "0 ..."
 case _ => "something else"
 }
 println(result)
 }
 }
}

方式二代碼實作：

object TestMatchList {
 def main(args: Array[String]): Unit = {
 val list: List[Int] = List(1, 2, 5, 6, 7)
 list match {
 case first :: second :: rest => println(first + "-" + 
second + "-" + rest)
 case _ => println("something else")
  }
 } 
}

匹配元組

代碼實作：

object TestMatchTuple {
 def main(args: Array[String]): Unit = {
 //對一個元組集合進行遍歷
 for (tuple <- Array((0, 1), (1, 0), (1, 1), (1, 0, 2))) {
 val result = tuple match {
 case (0, _) => "0 ..." //是第一個元素是 0 的元組
 case (y, 0) => "" + y + "0" // 匹配后一個元素是 0 的對偶元組
 case (a, b) => "" + a + " " + b
 case _ => "something else" //默認
 }
 println(result)
 }
 }
}

匹配物件及樣例類

代碼示例：

class User(val name: String, val age: Int)
object User{
 def apply(name: String, age: Int): User = new User(name, age)
 def unapply(user: User): Option[(String, Int)] = {
 if (user == null)
 None
 else
 Some(user.name, user.age)
 } 
}
object TestMatchUnapply {
 def main(args: Array[String]): Unit = {
 val user: User = User("zhangsan", 11)
 val result = user match {
 case User("zhangsan", 11) => "yes"
 case _ => "no"
 }
 println(result)
 } 
}

小結

val user = User("zhangsan",11)，該陳述句在執行時，實際呼叫的是 User 伴生物件中的apply 方法，因此不用 new 關鍵字就能構造出相應的物件，
當將 User("zhangsan", 11)寫在 case 后時[case User("zhangsan", 11) => "yes"]，會默認呼叫 unapply 方法(物件提取器)，user 作為 unapply 方法的引數，unapply 方法將 user 物件的 name 和 age 屬性提取出來，與 User("zhangsan", 11)中的屬性值進行匹配
case 中物件的 unapply 方法(提取器)回傳 Some，且所有屬性均一致，才算匹配成功,屬性不一致，或回傳 None，則匹配失敗，
若只提取物件的一個屬性，則提取器為 unapply(obj:Obj):Option[T]，若提取物件的多個屬性，則提取器為 unapply(obj:Obj):Option[(T1,T2,T3…)]，若提取物件的可變個屬性，則提取器為 unapplySeq(obj:Obj):Option[Seq[T]]

函式柯里化&閉包

閉包定義：

閉包：如果一個函式,訪問到了它的外部（區域）變數的值，那么這個函式和他所處的環境,稱為閉包
代碼示例：

package cn.doitedu.data_export

import org.apache.commons.lang3.RandomUtils
object CloseTest {
  def main(args: Array[String]): Unit = {
    val fx = (a:Int,b:Int)=>{
      a+b
    }

    val fxx = (a:Int) => {
      (b:Int)=>a+b
    }

    val res = fxx(3)(10)

    val f = () => {
      var p = RandomUtils.nextInt(1,10)

      val inner = () => {
        p += 1
        p
      }
      inner
    }

    val x1= f()
    println(x1())
    println(x1())

    println("-----------")

    val x2 = f()
    println(x2())
    println(x2())
    println(x2())
  }
}

柯里劃函式的定義：

函式柯里化：把一個引數串列的多個引數,變成多個引數串列，
意義: 方便資料的演變, 后面的引數可以借助前面的引數推演 , foldLeft的實作
有多個引數串列的函式就是柯里化函式，所謂的引數串列就是使用小括號括起來的函式引數串列
curry化最大的意義在于把多個引數的function等價轉化成多個單引數function的級聯，這樣所有的函式就都統一了，方便做lambda演算，在scala里，curry化對型別推演也有幫助，scala的型別推演是區域的，在同一個引數串列中后面的引數不能借助前面的引數型別進行推演，curry化以后，放在兩個引數串列里，后面一個引數串列里的引數可以借助前面一個引數串列里的引數型別進行推演，這就是為什么 foldLeft這種函式的定義都是curry的形式

惰性加載

當函式回傳值被宣告為 lazy 時，函式的執行將被推遲，直到我們首次對此取值，該函式才會執行，這種函式我們稱之為惰性函式，
代碼示例：

def main(args: Array[String]): Unit = {
 lazy val res = sum(10, 30)
 println("----------------")
 println("res=" + res)
}
def sum(n1: Int, n2: Int): Int = {
 println("sum 被執行，，，")
 return n1 + n2
}

運行結果：
----------------
sum 被執行，，，
res=40

注意：lazy 不能修飾 var 型別的變數

隱式轉換

隱式函式

隱式轉換可以在不需改任何代碼的情況下，擴展某個類的功能
練習：通過隱式轉化為 Int 型別增加方法，

//創建一個隱式方法，在def 前面加上關鍵字 implicit  讓一個型別具有更加豐富的功能
implicit def stringWrapper(str:String)={
  new MyRichString(str)
}

class MyRichString(val str:String){
  def fly()={
    println(str+",我是字串，我能飛！！")
  }

  def jump()={
    str + ":我能跳！"
  }
}

package com.doit.day02
import com.doit.day01.AnythingElse.Else._
/**
 * 隱式轉換：說白了就是給一個函式，引數，類 賦予更加強大的功能
 */
object _10_隱式轉換 {
  def main(args: Array[String]): Unit = {
    //1 本身是int 型別的，但是他卻可以呼叫richInt這個類里面的方法
    /**
     *  implicit def intWrapper(x: Int)= {
     *  //相當于創建了一個 RichInt的物件
     *    new runtime.RichInt(x)
     *  }
     *  我寫了一個隱式方法，傳進去一個引數，回傳給我的是一個物件， 并且在這個方法最前面加上了implicit 關鍵字 ，那么
     *  這個引數的型別 就具備了該類的方法
     */
    val str: String = "zss"
    str.fly()
  }
}

隱式引數

普通方法或者函式中的引數可以通過 implicit 關鍵字宣告為隱式引數，呼叫該方法時，
就可以傳入該引數，編譯器會在相應的作用域尋找符合條件的隱式值
說明：

同一個作用域中，相同型別的隱式值只能有一個
編譯器按照隱式引數的型別去尋找對應型別的隱式值，與隱式值的名稱無關，
隱式引數優先于默認引數

代碼示例：

//定義了一個方法，方法中的引數設定的是隱式引數
def add(implicit a: Int, b: String) = {
  a + b.toInt
}

//定義兩個變數，前面用implicit  修飾  變成隱式的
implicit val a:Int = 10
implicit val b:String = "20"

//呼叫方法的時候，如果沒有傳引數，那么他會去背景關系中找是否又隱式引數，如果有
//他就自己偷偷的傳進去了，如果沒有，會直接報錯
add

隱式類

在 Scala2.10 后提供了隱式類，可以使用 implicit 宣告類，隱式類的非常強大，同樣可
以擴展類的功能，在集合中隱式類會發揮重要的作用，
說明：

其所帶的構造引數有且只能有一個
隱式類必須被定義在“類”或“伴生物件”或“包物件”里，即隱式類不能是頂級的，

代碼示例：

implicit class snake(ant:Ant){
  def eatElephant()={
    println("i can eat elephant!!")
  }
}

val ant: Ant = new Ant
ant.eatElephant()

隱式決議機制

首先會在當前代碼作用域下查找隱式物體（隱式方法、隱式類、隱式物件），
如果第一條規則查找隱式物體失敗，會繼續在隱式引數的型別的作用域里查找，型別的作用域是指與該型別相關聯的全部伴生物件以及該型別所在包的包物件，

代碼示例：

package com.chapter10
import com.chapter10.Scala05_Transform4.Teacher
//（2）如果第一條規則查找隱式物體失敗，會繼續在隱式引數的型別的作用域里查找，
型別的作用域是指與該型別相關聯的全部伴生模塊，
object TestTransform extends PersonTrait {
 def main(args: Array[String]): Unit = {
 //（1）首先會在當前代碼作用域下查找隱式物體
 val teacher = new Teacher()
 teacher.eat()
 teacher.say()
 }
 class Teacher {
 def eat(): Unit = {
 println("eat...")
 }
 } 
}
trait PersonTrait {
}
object PersonTrait {
 // 隱式類 : 型別 1 => 型別 2
 implicit class Person5(user:Teacher) {
 def say(): Unit = {
 println("say...")
 }
 }
}

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/555559.html

標籤：其他

上一篇：尚醫通-day14【創建訂單】（內附原始碼）

下一篇：返回列表

Scala高階語法

高階函式

函式可以作為引數進行傳遞和回傳值進行回傳

匿名函式

偏函式

偏函式的定義：

案例：將集合中的所有的Int型別的資料都加上1

偏函式原理

偏函式的執行流程

偏函式的簡寫形式

偏函式總結

模式匹配

基本語法

模式守衛

模式匹配型別

匹配常量

匹配型別

匹配陣列

匹配串列

匹配元組

匹配物件及樣例類

函式柯里化&閉包

閉包定義：

柯里劃函式的定義：

惰性加載

隱式轉換

隱式函式

隱式引數

隱式類

隱式決議機制