模式匹配

1. 模式匹配：就是對變量的進行判斷，針對不同的條件進行不同的處理

2. 模式匹配的關鍵點：變量A中的數據類型包含case中所有的數據類型（變量A的數據類型是模式匹配中類型xx的向上轉型）

3. 模式匹配的幾種情況：

   1. 對值進行匹配 

   2. 對數據類型進行匹配 ：基本語法(變量A match {case 變量: 類型 => 代碼})

   3. 對集合數組進行匹配（如：Array和List）

   4. 對case class 進行模式匹配

   5. 對Option[T]進行模式匹配
   6. 模式匹配和高級函數連用：基本語法     list.map{case xxx => 函數體} （list中的每一個值都進行一次模式匹配）

4. match case 的基本語法：變量A match {case xx => 代碼塊}    模式匹配從上往下匹配，只要case 滿足條件，就不會繼續匹配判斷下面的分支了

5. 如果上面所有情況下的都沒有匹配到，最后用_表示其他類型。（默認是_,也可以用其他的變量名）

6. 模式匹配可以在case后的條件里面再加一個if條件

7. 如果匹配到的是一個變量名稱xx，則就會將匹配值A賦值給這個變量xx

8. 在高階函數中使代碼更具有可讀性

值匹配

對值進行模式匹配

   object valueTest{
        def main(args: Array[String]): Unit = {
          def Score(score:String): Unit ={
            score match {
              case "A"=>println("very good")
              case "B"=>println("good")
              case "C"=>println("just soso")
              case other  =>println("terrible")     //默認是_,也可以用其他的變量名
            }
          }
          Score("D")
        }
      }

在模式匹配中使用if守衛：在case后的條件里面再加一個if條件

object valueTest{
      def main(args: Array[String]): Unit = {
        def Score(name:String,score:String): Unit ={
          score match {
            case "A"=>println("very good")
            case "B"=>println("good")
            case "C"=>println("just soso")
            case _ if name=="James"=>print(s"come on !!!  $name")   //if守衛
            case _ =>println("terrible")
          }
        }
        Score("James","F")
      }
    }

 

在模式匹配中進行變量賦值：如果模式匹配的默認情況為一個變量名xx，則就會將要匹配的值A賦值給這個變量xx，可以在后面的處理語句中使用該值

object valueTest{
      def main(args: Array[String]): Unit = {
        def Score(name:String,score:String): Unit ={
          score match {
            case "A"=>println("very good")
            case "B"=>println("good")
            case "C"=>println("just soso")
            case _ if name=="James"=>print(s"come on !!!  $name")
            case other  =>println("terrible, you just "+other)  //變量賦值
          }
        }
        Score("Jamues","F")
      }
    }

數據類型匹配

基本語法:變量A match {case 變量: 類型 => 代碼}

//變量Excep的數據類型是模式匹配中類型excipn的父類
object ExceptionTest{
  def main(args: Array[String]): Unit = {
    import java.io._
    def funException(Excep: Exception) {
      Excep match {
        case excip1: IllegalArgumentException => println(excip1)
        case excip2: FileNotFoundException => println( excip2)
        case excip3: IOException => println( excip3)
        case _: Exception => println("............" )
      }
    }
    funException(new IOException("..."))
  }
}

集合數組匹配

1. 可以匹配帶有指定元素的數組

2. 特定結構

3. 以某元素打頭的數組

object ArrayTest{
  def main(args: Array[String]): Unit = {
    def playBall(arr: Array[Any]) {
      arr match {
        case Array("basketball") => println("play basketball")  //匹配一個元素
        case Array(ball1,(ball2,ball3)) => println("一個單個元素，一個二元組") //匹配特定結構
        case Array("ball", _*) => println("ball start ") //匹配以ball開頭
        case _ => println("hey, who are you?")
      }
    }
    playBall(Array("ball"))
  }
}

 

case class匹配

變量person是case中匹配對象的父類

class Person
case class Teacher(name: String, subject: String) extends Person
case class Student(name: String, classroom: String) extends Person
object MatchTest {
    def main(args: Array[String]): Unit = {
      def judgeIndentity(person: Person): Unit = {
        person match {
          case Teacher(name, subject) => println(s"name = $name, subject = $subject")
          case Student(name, classroom) => println(s"name = $name, classroom = $classroom")
          case _ => println("........................")
        }
      judgeIndentity(Student("xz", "1001"))
    }
  }
}

 

Option[T]匹配

Option[T]用在模式匹配中用來判斷變量是否有值（對有值和無值做不同的處理）

object OptionTest{
  def main(args: Array[String]): Unit = {
    val person = Map(("Tom",15),("Wiki",26))
    val age: Option[Int] = person.get("Toms")
      age match {
        case Some(grade) => println(s" is ${age.get} years")
        case None => println("who are you")
      }
  }
}

 模式匹配和高級函數連用

 

1. 基本語法： list.map{case xxx =>  函數體}

2. list中的每一個值都進行一次模式匹配

3. 在高階函數中使代碼更具有可讀性

object MatchTest {
    def main(args: Array[String]): Unit = {
      // 將列表中字母變成大寫
      val list  = List((1, ("aa", 11)), (2, ("bb", 22)), (3, ("cc", 33)))
      list.map(item => (item._1, (item._2._1.toUpperCase, item._2._2)))

      // 模式匹配使代碼更具有可讀性
      list.map{
        case (id,(na,ages)) =>(id,(na.toUpperCase(),ages))
      }
  }
}