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