模式匹配（二十）

簡介

  Scala 提供了強大的模式匹配機制，應用非常廣泛。一個模式匹配包含了一系列備選項，每個都開始於關鍵字 case。每個備選項都包含了一個模式及一到多個表達式。箭頭符號 => 隔開了模式和表達式。

模式匹配入門

簡單實例

object PatternMatching extends App{
  for(i<- 1 to 100){
    i  match {
      case 10 => println(10)
      case 50 => println(50)
      case 80 => println(80)
      case _ => 
    }
  }
}

更爲靈活的匹配方式

object PatternMatching extends App{
  for(i<- 1 to 100){
    i  match {
      case 10 => println(10)
      case 50 => println(50)
      case 80 => println(80)
      //增加守衛條件
      case _ if(i%4==0)=> println(i+":能被4整除")
      case _ if(i%3==0)=> println(i+":能被3整除")
      case _ =>
    }
  }
}

模式類型

常量模式

object ConstantPattern{
  def main(args: Array[String]): Unit = {
    //注意，下面定義的是一個函數
    //函數的返回值利用的是模式匹配後的結果作爲其返回值
    //還需要注意的是函數定義在main方法中
    //也即scala語言可以在一個函數中定義另外一個函數
    def patternShow(x:Any)=x match {
      case 5 => "five"
      case true=>"true"
      case "test"=>"String"
      case null=>"null"
      case Nil=>"empty list"
      case _  =>"Other constant"
    }    
    println(patternShow(5))
  }
}

變量模式

object VariablePattern{
  def main(args: Array[String]): Unit = {
    def patternShow(x:Any)=x match {
      case 5 => "five"
      //所有不是值爲5的都會匹配變量y
      //例如"xxx"，則函數的返回結果就是"xxx"
      case y => y
    }   
    println(patternShow("xxx"))
  }
}

構造器模式

//構造器模式必須將類定義爲case class
case class Person(name:String,age:Int)
object ConstructorPattern {
  def main(args: Array[String]): Unit = {
      val p=new Person("搖擺少年夢",27)
      def constructorPattern(p:Person)=p match {
        case Person(name,age) => "Person"
        case _ => "Other"
      }
  }
}

序列模式

  序列模式指的是像Array、List這樣的序列集合進行模式匹配。

object SequencePattern {
  def main(args: Array[String]): Unit = {
      val p=List("spark","hive","SparkSQL")
      def sequencePattern(p:List[String])=p match {
        //只需要匹配第二個元素
        case List(_,second,_*) => second
        case _ => "Other"
      }
      println(sequencePattern(p))
  }
}

元組模式

//匹配某個元組內容
object TuplePattern {
  def main(args: Array[String]): Unit = {
      val t=("spark","hive","SparkSQL")
      def tuplePattern(t:Any)=t match {
        case (one,_,_) => one
        case _ => "Other"
      }
      println(tuplePattern(t))
  }
}

類型模式

//匹配傳入參數的類型
object TypePattern {
  def main(args: Array[String]): Unit = {

      def tuplePattern(t:Any)=t match {
        case t:String=> "String"
        case t:Int => "Integer"
        case t:Double=>"Double"
      }
      println(tuplePattern(5.0))
  }
}

變量綁定模式

object VariableBindingPattern {
  def main(args: Array[String]): Unit = {
       var t=List(List(1,2,3),List(2,3,4))      
       def variableBindingPattern(t:Any)= t match {
         //變量綁定，採用變量名（這裏是e)
         //與@符號，如果後面的模式匹配成功，則將
         //整體匹配結果作爲返回
         case List(_,e@List(_,_,_)) => e
         case _ => Nil
       }

       println(variableBindingPattern(t))
  }
}
//編譯執行後的輸出結果爲  List(2, 3, 4)

for控制結構中的模式匹配

object PatternInForLoop {
  def main(args: Array[String]): Unit = {
    val m=Map("china"->"beijing","dwarf japan"->"tokyo","Aerican"->"DC Washington")
    //利用for循環對Map進行模式匹配輸出，
    for((nation,capital) <- m)
      println(nation + ": " + capital)
  }
}

正則表達式中的模式匹配

object RegexMatch {
  def main(args: Array[String]): Unit = {
    val ipRegex="(\\d+)\\.(\\d+)\\.(\\d+)\\.(\\d+)".r
    for(ipRegex(one,two,three,four) <- ipRegex.findAllIn("192.168.1.1")){
      println("IP子段1:"+one)
      println("IP子段2:"+two)
      println("IP子段3:"+three)
      println("IP子段4:"+four)
    }
  }
}

Option類型模式匹配

簡介

  Option類是一個sealed class，Some是case class，None是case object。

  case object與case class所不同的是，case object對應反編譯後的CaseObject$.class中不存在apply、unapply方法。因爲None不需要創建對象及進行內容提取，從這個角度講，它被定義爲case object是十分合理的。

簡單實例

object OptionDemo extends App{
  val m=Map("hive"->2,"spark"->3,"Spark MLlib"->4)

  def mapPattern(t:String)=m.get(t) match {
    case Some(x) => println(x);x
    case None => println("None");-1
  }

  println(mapPattern("Hive"))
}
//輸出結果爲：
//None
//-1

---

忠於技術，熱愛分享。歡迎關注公衆號：java大數據編程，瞭解更多技術內容。