scala中的模式匹配

基本语法

 变量 match {
   case 值1 => 代码
   case 值2 => 代码
   ...
   case 值N if (...) => 代码
   case _ => 代码
 }

常量匹配

 scala> def matchConstant(x:Any) = x match {
      |   case 1 => "One"
      |   case "two" => "Two"
      |   case "3" => "Three"
      |   case true => "True"
      |   case null => "null value"
      |   case Nil => "empty list"
      |   case _ => "other value"
      | }

特别需要注意的是，Nil是一个空的List，定义为List[Nothing]。

变量匹配

 scala> def matchVariable(x:Any) = x match {
      |    case x if(x==1) => x
      |    case x if(x=="Tony") => x
      |    case x:String => "other value:" + x
      |    case _ => "unexpected value:"+x
      | }

类型匹配

 scala> def matchType(x:Any) = x match {
      |   case s:String => "the string length is:"+s.length
      |   case m:Map[_,_] => "the map size is:"+m.size
      |   case _:Int | _:Double => "the number is:"+x
      |   case _ => "unexpected value:"+x
      | }

case class匹配

 class DataFrameWork
 case class ComputationFramework(name: String, pupular:Boolean) extends  DataFrameWork
 case class StorageFramework(name:String, popular:Boolean) extends DataFrameWork

 def getBigDataType(data: DataFrameWork){
     data match {
       case ComputationFramework(name, popular) => println("[ComputationFramework]name: " + name + " and popular: " + popular)
       case StorageFramework(name, popular) => println("[StorageFramework]name: " + name + " and popular: " + popular)
       case _ => println("Other situation")
     }
   }

option匹配

Scala有一种特殊的类型Option,Option有两种值，一种是Some，表示有值，一种是None，表示没有值。Option通常会用于模式匹配中，用于判断某个变量是有值还是没有值，这比null来的更加简洁明了。

 def getValue(key:String, content:Map[String, String]){
     content.get(key) match {
       case Some(value) => println(value)
       case None => println("NOT FIND")
     }
   }

数组匹配

 def getMatchCollection(msg : Array[String]) {
     msg match {
       case Array("Scala") => println("One Element")
       case Array("Scala", "Java") => println("Two Element")
       case Array("Spark", _*) => println("Some Element begin with Spark")
       case _ => println("Unknown type")
     }
   }

元组匹配

 def tupleMatch(t : Tuple2[String, String]) : String = t match {
     case ("A", _) => "匹配以A开始的二元组"
     case (_, "A") => "匹配以A结束的二元组"
     case _ => "其他情况"
 }

List匹配

def listMatch(list : List[String]) = list match {
    case head :: Nil => "匹配只有一个元素的情况"
    case x :: y :: Nil => "匹配只有两个元素的情况"
    case "丽丽" :: tail => "匹配以丽丽开始的情况"
    case head :: tail => "匹配多个元素的情况"
    case _ => "其他情况"
}

list分为head和tail两个部分，head是list的第一个元素，tail是list中除了head外的其余元素组成的list。用::连接list时，尾节点要声明成Nil。

变量绑定

可以将匹配的对象绑定到变量上。首先写一个变量名，然后写一个@符号，最后写入该匹配的对象。如果匹配成功，则将变量设置为匹配的对象。

 scala> case class Person(name: String, age: Int)
 defined class Person

 scala> val person = Person("Tony",18)
 person: Person = Person(Tony,18)

 scala> person match {
      |   case p @Person(_,age) => println(s"${p.name},age is $age")
      |   case _ => println("Not a person")
      | }
 Tony,age is 18

参考：

https://www.jianshu.com/p/d07e0bcfea3a

https://www.jianshu.com/p/1456f065a4bb