scala裏的模式匹配和Case Class

模式匹配的簡介

　　scala語言裏的模式匹配能夠看做是java語言中switch語句的改進。

 

模式匹配的類型

　　包括：常量模式、變量模式、構造器模式、序列模式、元組模式以及變量綁定模式等。

 

 

常量模式匹配

　　常量模式匹配，就是在模式匹配中匹配常量啦。

objectConstantPattern{
　　def main(args:Array[String]) :Unit = {
　　　　//模式匹配結果做爲函數返回值
　　　　defpatternShow(x : Any) = x match {
　　　　　　case 5 => "五"
　　　　　　case true => "真"
　　　　　　case "test" => "字符串"
　　　　　　case null => "null值"
　　　　　　case Nil => "空列表"
　　　　　　case _ => "其餘常量"
　　　　}
　　　　println(patternShow(5))
　　　　println(patternShow(true))
　　　　println(patternShow(List()))
　　}
}

 

 

 

 

變量匹配

　　變量匹配，匹的是case語句後面接的是scala變量，如case x if(x == 5) => x等，在使用時通常會加守衛條件，固然也能夠像case x => x這樣使用，它會匹配任何輸入的合法變量。

objectVariablePattern{
　　def main(args:Array[String]) :Unit = {
　　//模式匹配結果做爲函數返回值
　　defpatternShow(x : Any) = x match {
　　　　case x if (x == 5) => x
　　　　case x if (x == "Scala") => x
　　　　case _ =>
　　}
　　println(patternShow(5))
　　println(patternShow("Scala"))
　　}
}

 

 

 

構造器模式

　　構造器模式指的是，直接在case語句後面接類構造器，匹配的內容放置在構造器參數中。

　　//將Person類定義爲case class
case class Person(name : String,age : Int)

object ConstructorPattern{
　　　　def main(args:Array[String]) :Unit = {
　　　　　　val p = new Person("nyz",27)
　　　　　　def constructorPattern(p : Person) = p match {
　　　　　　　　//構造器模式必須將Person類定義爲case class,不然須要本身定義伴生對象並實現unapply方法。
　　　　　　　　case Person(name,age) => "name =" + name + ",age =" + age
　　　　　　　　//case Person(_,age) => "age =" + age
　　　　　　　　case _ => "Other"
　　　　　　}
　　　　　　println(constructorPattern(p))
　　　　}
}

 

 

序列化模式
　　序列模式用於匹配如數組Array、列表List、Range這樣的線性結構集合，其實原理也是經過case class起做用的。

object SequencePattern{
　　def main(args:Array[String]) :Unit = {
　　　　val list = List("spark","Hive","SparkSQL")
　　　　val arr = Array("SparkR","Spark Streaming","Spark MLib")
　　def sequencePattern(p : Any) = p match {{
　　　　//序列模式匹配，_*表示匹配剩餘內容，first、second匹配數組p中的第1、二個元素
　　　　case Array(first,second,_*) => first + "," + second
　　　　//_匹配數組p的第一個元素，但不賦給任何變量
　　　　case List(_,second,_*) => second
　　　　case _ => "Other"
　　}
　　println(SequencePattern(list))
　　println(SequencePattern(arr))
　　}
}

 

 

 

元組模式
　　元組模式用於匹配scala中的元組內容，用於匹配元組類型的變量內容。
object TuplePattern{
　　def main(args:Array[String]) :Unit = {
　　　　val list = List("spark","Hive","SparkSQL")
　　def tuplePattern(t : Any) = t match {{
　　　　case (one,_,_) => one
　　　　//_*不適合用於元組，只適用於序列
　　　　//case (one,_*) => one
　　　　case _ => "Other"
　　}
　　println(tuplePattern(t))
　　}
}

 

 

 

 

 

類型模式
　　它能夠匹配輸入待匹配變量的類型
object TypePattern{
　　def main(args:Array[String]) :Unit = {
　　def typePattern(t : Any) = t match {{
　　　　case t : String => "String"
　　　　case t : Int => "Intger"
　　　　case t : Double => "Double"
　　　　case _ => "Other Type"
　　}
　　println(typePattern(5.0))
　　println(typePattern(5))
　　println(typePattern("5"))
　　println(typePattern(List()))
　　}
}

 

 

 

 

變量綁定模式
　　在進行模式匹配時，有時不單單只是返回一個變量，也能夠將某個變量綁定到某個模式上。
　　從而將總體匹配結果賦值給該變量。
具體使用方法是在模式前面加變量和@符號。
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))
　　}
}

 

 

 

 

 

 

 

 

package com.dt.spark.scala.basics

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

object HelloPatternMatch { 　　def main(args: Array[String]): Unit = { 　　　　getSalary("Hadoop MapReduce")　　　　// getSalary("cdcdc",6) 　　　　getMatchType(100) 　　　　getMatchCollection(Array("Spark","Python")) 　　 　　　　getBigDataType(ComputationFramework("Spark",true)) 　　　　getBigDataType(ComputationFramework("Spark",false)) 　　　　getBigDataType(StorageFramework("HDFS",true)) 　　　　getValue("Spark",Map("Spark" -> "The hottest！" , "Hadoop " -> "The old ！")) 　　} 　　//對於匹配模式來講，不需什麼break，只要匹配到，就不往下了 　　def getSalary(name : String) {　　// def getSalary(name : String,age : Int) { 　　　　name match { 　　　　　　case "Spark" => println("$1500/year")//表示，若是傳入是Spark，則說明匹配成功，執行=>後的語句 　　　　　　case "Hadoop" => println("$1000/year") 　　　　　　case _ if name == "Scala" => println("$1800/year")//_ if name == "Scala"是守衛條件的方式， 　　　　　　case _ if name == "Hadoop MapReduce" => println("$800/year")　　　　　　// case _name if age >= 5 => println("name : " + _name + " age : " + age + "$100/year")//getSalary("cdcdc",6) 　　　　　　case _ => println("$90/year")//_是前面沒匹配的。即其餘 　　　　　　//如case _ if (i%4 ==0) => println("$1800/year")這是帶守衛條件的方式，對變量的值進行判斷。 　　　　} 　　} 　　def getMatchType(msg : Any) { 　　　　msg match { 　　　　　　case i : Int => println("Integer") 　　　　　　case s : String => println("String") 　　　　　　case d : Double => println("Double") 　　　　　　case array : Array[Int] => println("Array") 　　　　　　case _ => println("Unkoen type") 　　　　} 　　} 　　def getMatchCollection(msg : Any) { 　　　　msg match { 　　　　　　case Array("Scala") => println("One element") 　　　　　　case Array("Scala","Java")=> println("Two element") 　　　　　　case Array("Spark", _*) => println("Many elements begins with Spark") 　　　　　　case _ => println("Unkoen type") 　　　　} 　　} 　　def getBigDataType(data : DataFrameWork) { 　　　　data match { 　　　　　　case ComputationFramework(name, popular) => println("ComputationFramework : " + "name : " + name + "popular : " + popular) 　　　　　　case StorageFramework(name, popular) => println("StorageFramework : " + "name : " + name + "popular : " + popular) 　　　　　　case _ => println("Some other type") 　　　　} 　　}　　 　　def getValue(key : String , content : Map[String,String]){ 　　　　content.get(key) match { 　　　　　　case Some(value) => println(value) 　　　　　　case None => println("Not Found!!!") 　　　　} 　　} }