12. Scala模式匹配

時間  2019-12-07
標籤 scala 模式 匹配 欄目 Scala 简体版
原文   原文鏈接

12.1 match 

　　12.1.1 基本介紹 

　　　　　　Scala中的模式匹配相似於Java中的switch語法，可是更增強大java

　　　　　　模式匹配語法中，採用match關鍵字聲明，每一個分支採用case關鍵字進行聲明，當須要匹配時，會從第一個case分支開始，若是匹配成功，那麼執行對應的邏輯代碼，若是匹配不成功，繼續執行下一個分支進行判斷。若是全部的case都不匹配，那麼會執行case_分支，相似於Java中的default語句git

　　12.1.2 scala的match的快速入門案例 

object boke_demo01 {

  def main(args: Array[String]): Unit = {
    val oper = '+'
    val n1 = 20
    val n2 = 10
    var res = 0
    //說明
    //1. match (相似java switch) 和  case 是關鍵字
    //2. 若是匹配成功， 則 執行 => 後面的代碼塊.
    //3. 匹配的順序是從上到下，匹配到一個就執行對應的 代碼
    //4. => 後面的代碼塊 不要寫 break ,會自動的退出match
    //5. 若是一個都沒有匹配到，則執行 case _ 後面的代碼塊
    oper match {
      case '+' => {
        res = n1 + n2
        println("ok~~")
        println("hello~~")
      }
      case '-' => res = n1 - n2
      case '*' => res = n1 * n2
      case '/' => res = n1 / n2
      case 1 => println("匹配到1")
      case 1.1 => println("匹配1.1")
      case _ => println("oper error")
    }
    println("res=" + res)

  }
}

　　12.1.3 match的細節和注意事項  

　　　　　　1) 若是全部case都不匹配，那麼會執行case_分支，相似於Java中的default語句程序員

　　　　　　2) 若是全部case都不匹配，又沒有寫case_分支，那麼會拋出MatchError數組

　　　　　　3) 每一個case中，不用break語句，自動中斷caseapp

　　　　　　4) 能夠在match中使用其它類型，而不單單是字符測試

　　　　　　5) => 等價於 java switch的 ：優化

　　　　　　6) => 後面的代碼塊到下一個case，是做爲一個總體執行，可使用{}擴起來，也能夠不擴scala

12.2 守衛

　　12.2.1 基本介紹 

　　　　　　若是想要表達匹配某個範圍的數據，就須要在模式匹配中增長條件守衛rest

　　12.2.2 應用案例  

object boke_demo01 {

  def main(args: Array[String]): Unit = {

    for (ch <- "+-3!") { //是對"+-3!" 遍歷
      var sign = 0
      var digit = 0
      ch match {
        case '+' => sign = 1
        case '-' => sign = -1
        // 說明..
        // 若是 case 後有 條件守衛即if ,那麼這時的 _ 不是表示默認匹配
        // 表示忽略 傳入 的 ch
        case _ if ch.toString.equals("3") => digit = 3
        case _ => sign = 2
      }
      //分析
      // + 1 0
      // - -1 0
      // 3 0 3
      // ! 2 0
      println(ch + " " + sign + " " + digit)
    }

  }
}

12.3 模式中的變量 

　　12.3.1 基本介紹  

　　　　　　若是在case關鍵字後跟變量名，那麼match前表達式的值會賦給那個變量對象

　　12.3.2 應用案例 

object boke_demo01 {

  def main(args: Array[String]): Unit = {
    val ch = 'U'
    ch match {
      case '+' => println("ok~")
      // 下面 case mychar 含義是 mychar = ch
      case mychar => println("ok~" + mychar)
      case _ => println("ok~~")
    }

    val ch1 = '+'
    //match是一個表達式，所以能夠有返回值
    //返回值就是匹配到的代碼塊的最後一句話的值
    val res = ch1 match {
      case '+' => ch1 + " hello "
      case _ => println("ok~~")
    }

    println("res=" + res)
  }
}

12.4 類型匹配 

　　12.4.1 基本介紹 

　　　　　　能夠匹配對象的任意類型，這樣作避免了使用isInstanceOf和asInstanceOf

　　12.4.2 應用案例 

object boke_demo01 {

  def main(args: Array[String]): Unit = {
    val a = 8
    //說明 obj 實例的類型 根據 a 的值來返回
    val obj = if (a == 1) 1
    else if (a == 2) "2"
    else if (a == 3) BigInt(3)
    else if (a == 4) Map("aa" -> 1)
    else if (a == 5) Map(1 -> "aa")
    else if (a == 6) Array(1, 2, 3)
    else if (a == 7) Array("aa", 1)
    else if (a == 8) Array("aa")

    //說明
    //1. 根據  obj 的類型來匹配
    // 返回值
    val result = obj match {

      case a: Int => a
      case b: Map[String, Int] => "對象是一個字符串-數字的Map集合"
      case c: Map[Int, String] => "對象是一個數字-字符串的Map集合"
      case d: Array[String] => d //"對象是一個字符串數組"
      case e: Array[Int] => "對象是一個數字數組"
      case f: BigInt => Int.MaxValue
      case y: Float => println("xx")
      case _ => "啥也不是"
    }

    println(result)

  }
}

　　12.4.3 類型匹配注意事項 

　　　　　　1) Map[String, Int]和Map[Int, String]是兩種不一樣的類型，其它類推

　　　　　　2) 在進行類型匹配時，編譯器會預先檢測是否有可能的匹配，若是沒有則報錯

object boke_demo01 {

  def main(args: Array[String]): Unit = {

    val obj = 10
    val result = obj match {
      case a: Int => a
      //case b: Map[String, Int] => "Map集合"    //取消註釋以後會報錯
      case _ => "啥也不是"
    }

  }
}

　　　　　　4) 若是case _ 出如今match中間，則表示隱藏變量名，即不使用，而不是表示默認匹配

　　　　　　　　

12.5 匹配數組 

　　12.5.1 基本介紹 

　　　　　　1) Array(0)匹配只有一個元素且爲0的數組

　　　　　　2) Array(x,y)匹配數組有兩個元素，並將兩個元素賦值爲x和y。固然能夠依次類推Array(x,y,z)匹配數組有三個元素，等等

　　　　　　3) Array(0,_*)匹配數組以0開始

　　12.5.2 應用案例 

import scala.collection.mutable.ArrayBuffer

object boke_demo01 {

  def main(args: Array[String]): Unit = {

    //    val arrs = Array(Array(0), Array(1, 0), Array(0, 1, 0),
    //      Array(1, 1, 0), Array(1, 1, 0, 1))
    //
    //    for (arr <- arrs ) {
    //      val result = arr match {
    //        case Array(0) => "0"
    //        case Array(x, y) => x + "=" + y
    //        case Array(0, _*) => "以0開頭和數組"
    //        case _ => "什麼集合都不是"
    //      }
    //      // result = 0
    //      // result = 1 = 0
    //      // result = 以0開頭和數組
    //      // result = 什麼集合都不是
    //      // result = 什麼集合都不是
    //      println("result = " + result)
    //    }

    //給你一個數組集合，若是該數組是  Array(10,20) , 請使用默認匹配，返回Array(20,10)


    val arrs2 = Array(Array(0), Array(1, 0), Array(0, 1, 0),
      Array(1, 1, 0), Array(1, 1, 0, 1))

    for (arr <- arrs2) {
      val result = arr match {
        //case Array(0) => "0"
        case Array(x, y) => ArrayBuffer(y, x) //Array(y,x).toBuffer //? ArrayB(y,x)
        //case Array(0, _*) => "以0開頭和數組"
        case _ => "不處理~~"
      }

      println("res=" + result) //ArrayBuffer(0,1)
    }

  }
}

12.6 匹配列表 

　　　　　　－案例演示

object boke_demo01 {

  def main(args: Array[String]): Unit = {

    for (list <- Array(List(0), List(1, 0), List(0, 0, 0), List(1, 0, 0))) {
      val result = list match {
        case 0 :: Nil => "0" //
        case x :: y :: Nil => x + " " + y //
        case 0 :: tail => "0 ..." //
        case x :: Nil => x
        case _ => "something else"
      }
      //1. 0
      //2. 1 0
      //3. 0 ...
      //4. something else
      println(result)
    }

  }
}

12.7 匹配元組 

　　　　　　－案例演示

object boke_demo01 {

  def main(args: Array[String]): Unit = {
    //若是要匹配 (10, 30) 這樣任意兩個元素的對偶元組，應該如何寫
    for (pair <- Array((0, 1), (1, 0), (10, 30), (1, 1), (1, 0, 2))) {
      val result = pair match { //
        case (0, _) => "0 ..." //
        case (y, 0) => y //
        case (x, y) => (y, x) //"匹配到(x,y)" + x + " " + y
        case _ => "other" //.
      }
      //1. 0 ...
      //2. 1
      //3. (30,10)
      //4. (1,1)
      //5. other
      println(result)
    }

  }
}

12.8 對象匹配 

　　12.8.1 基本介紹 

　　　　　　對象匹配，什麼纔算是匹配呢？規則以下：

　　　　　　　　1) case中對象的unapply方法(對象提取器)返回Some集合則爲匹配成功

　　　　　　　　2) 返回None集合則爲匹配失敗

　　12.8.2 快速入門 

object boke_demo01 {

  def main(args: Array[String]): Unit = {

    // 模式匹配使用：
    val number: Double = Square(6.0) // 36.0 //

    number match {
      //說明 case Square(n) 的運行的機制
      //1. 當匹配到 case Square(n)
      //2. 調用Square 的 unapply(z: Double),z 的值就是 number
      //3. 若是對象提取器 unapply(z: Double) 返回的是Some(6) ,則表示匹配成功，同時
      //   將6 賦給 Square(n) 的n
      //4.  果對象提取器 unapply(z: Double) 返回的是None ,則表示匹配不成功
      case Square(n) => println("匹配成功 n=" + n)
      case _ => println("nothing matched")
    }


  }
}

//說明

object Square {
  //說明
  //1. unapply方法是對象提取器
  //2. 接收z:Double 類型
  //3. 返回類型是Option[Double]
  //4. 返回的值是 Some(math.sqrt(z)) 返回z的開平方的值，並放入到Some(x)
  def unapply(z: Double): Option[Double] = {
    println("unapply被調用 z 是=" + z)
    Some(math.sqrt(z))
    //None
  }

  def apply(z: Double): Double = z * z
}

　　12.8.3 應用案例2 

　　　　　　－案例演示

object boke_demo01 {

  def main(args: Array[String]): Unit = {

    val namesString = "Alice,Tom,Jack" //字符串
    //說明
    namesString match {
      // 當 執行   case Names(first, second, third)
      // 1. 會調用 unapplySeq（str）,把 "Alice,Tom,Jack" 傳入給 str
      // 2. 若是 返回的是 Some("Alice","Tom","Jack"),分別給 （first, second, third）
      //    注意，這裏的返回的值的個數須要和 （first, second, third）要同樣
      // 3. 若是返回的None ,表示匹配失敗

      case Names(first, second, third) => {
        println("the string contains three people's names")
        // 打印字符串
        println(s"$first $second $third")
      }
      case _ => println("nothing matched")
    }

  }
}

//object
object Names {
  //當構造器是多個參數時，就會觸發這個對象提取器
  def unapplySeq(str: String): Option[Seq[String]] = {
    if (str.contains(",")) Some(str.split(","))
    else None
  }
}

　　　　　　－案例演示小結

　　　　　　　　1) 當case後面的對象提取器方法的參數爲多個，則會默認調用def unapplySeq()方法

　　　　　　　　2) 若是unapplySeq返回的是Some，獲取其中的值，判斷獲得的sequence中的元素的個數是不是三個，若是是三個，則把三個元素分別取出，賦值給first，second和third

　　　　　　　　3) 其它的規則不變

12.9 變量聲明中的模式  

　　12.9.1 基本介紹 

　　　　　　match中每個case均可以單獨取出來，意思是同樣的

　　12.9.2 應用案例 

object boke_demo01 {

  def main(args: Array[String]): Unit = {

    val (x, y, z) = (1, 2, "hello")
    println("x=" + x)
    val (q, r) = BigInt(10) /% 3 //說明  q = BigInt(10) / 3 r = BigInt(10) % 3
    val arr = Array(1, 7, 2, 9)
    val Array(first, second, _*) = arr // 提出arr的前兩個元素
    println(first, second)

  }
}

12.10 for表達式中的模式 

　　12.10.1 基本介紹 

　　　　　　for循環也能夠進行模式匹配

　　12.10.2 應用案例 

object boke_demo01 {

  def main(args: Array[String]): Unit = {
    val map = Map("A" -> 1, "B" -> 0, "C" -> 3)
    for ((k, v) <- map) {
      println(k + " -> " + v) // 出來三個key-value ("A"->1), ("B"->0), ("C"->3)
    }
    //說明 : 只遍歷出 value =0 的key-value ,其它的過濾掉
    println("--------------(k, 0) <- map-------------------")
    for ((k, 0) <- map) {
      println(k + " --> " + 0)
    }

    //說明, 這個就是上面代碼的另外寫法, 只是下面的用法靈活和強大
    println("--------------(k, v) <- map if v == 0-------------------")
    for ((k, v) <- map if v >= 1) {
      println(k + " ---> " + v)
    }

  }
}

12.11 樣例(模版)類 

　　12.11.1 樣例類快速入門 

object CaseClassDemo01 {
  def main(args: Array[String]): Unit = {
      println("hello~~")
  }
}

abstract class Amount
case class Dollar(value: Double) extends Amount    //樣例類
case class Currency(value: Double, unit: String) extends Amount //樣例類
case object NoAmount extends Amount  //樣例類

　　12.11.2 基本介紹 

　　　　　　1) 樣例類仍然是類

　　　　　　2) 樣例類用case關鍵字進行聲明

　　　　　　3) 樣例類是爲模式匹配而優化的類

　　　　　　4) 構造器中的每個參數都成爲val－除非它被顯式地聲明爲var(不建議這樣作)

　　　　　　5) 在樣例類對應的伴生對象中提供apply方法，不用new關鍵字就能構造出相應的對象

　　　　　　6) 提供unapply方法讓模式匹配能夠工做

　　　　　　7) 將自動生成toString、equals、hashCode和copy方法(有點相似模版類，直接給生成，供程序員使用)

　　　　　　8) 除上述外，樣例類和其它類徹底同樣。能夠添加字段和方法，擴展它們

　　12.11.3 應用案例1 

　　　　　　－案例演示

object boke_demo01 {

  def main(args: Array[String]): Unit = {
    //該案例的做用就是體驗使用樣例類方式進行對象匹配簡潔性
    for (amt <- Array(Dollar(1000.0), Currency(1000.0, "RMB"), NoAmount)) {
      val result = amt match {
        //說明
        case Dollar(v) => "$" + v // $1000.0
        //說明
        case Currency(v, u) => v + " " + u // 1000.0 RMB
        case NoAmount => "NoAmount" // NoAmount
      }
      println(amt + ": " + result)
    }

  }
}

abstract class Amount

case class Dollar(value: Double) extends Amount //樣例類
case class Currency(value: Double, unit: String) extends Amount //樣例類
case object NoAmount extends Amount //樣例類

　　12.11.4 應用案例2 

　　　　　　－說明

　　　　　　　　樣例類的copy方法和帶名參數

　　　　　　　　copy建立一個與現有對象值相同的新對象，並能夠經過帶名參數來修改某些屬性

　　　　　　－案例演示

object boke_demo01 {

  def main(args: Array[String]): Unit = {
    val amt = new Currency(3000.0, "RMB")
    val amt2 = amt.copy() // 克隆,建立的對象和amt的屬性同樣
    println("amt2.value" + amt2.value + " amt2.unit= " + amt2.unit)
    println(amt2)

    val amt3 = amt.copy(value = 8000.0)
    println(amt3)

    val amt4 = amt.copy(unit = "美圓")
    println(amt4)
  }
}


abstract class Amount

case class Dollar(value: Double) extends Amount //樣例類
case class Currency(value: Double, unit: String) extends Amount //樣例類
case object NoAmount extends Amount //樣例類

12.12 case語句的中置(綴)表達式 

　　12.12.1 基本介紹 

　　　　　　什麼是中置表達式？1 + 2，這就是一箇中置表達式。若是unapply方法產出一個元組，能夠在case語句中使用中置表示法。好比能夠匹配一個List序列

　　12.12.2 應用案例 

　　　　　　－案例演示

object boke_demo01 {

  def main(args: Array[String]): Unit = {
    List(1, 3, 5, 9) match { //修改並測試
      //1.兩個元素間::叫中置表達式,至少first，second兩個匹配才行.
      //2.first 匹配第一個 second 匹配第二個, rest 匹配剩餘部分(5,9)
      case first :: second :: rest => println(first + " " + second + " " + rest.length + " " + rest) //
      case _ => println("匹配不到...")
    }

  }
}

12.13 密封類 

　　12.13.1 基本介紹 

　　　　　　1) 若是想讓case類的全部子類都必須在申明該類的相同的源文件中定義，能夠將樣例類的通用超類聲明爲sealed，這個超類稱之爲密封類

　　　　　　2) 密封就是不能在其它文件中定義子類

　　　　　　

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程