基本模式匹配：

點選(此處)摺疊或開啟

def main(args: Array[String]) {
val data =2
data match {
case 1 => println("First") //類似於函式的定義與實現（case可以是變數，也可以是條件表示式）
case 2 => println("Second") //不同於java，這裡不需要break關鍵字，匹配之後會自動返回
case _ => println("Not Known Number") //預設情況
}
val result = data match { //match可以返回結果
case i if i == 1 => "The First" //val i常量，使用match時，data傳進來時就會賦值給i
case number if number ==2 => "The Second" + number //number的初始化同i，並且number在case語句，以及函式體中都可以被使用。
case _ => "Not Known Number"
}
println(result)
"Spark !" foreach { c => println (
c match {
case ' ' => "space"
case ch => "Char: " + ch
}
)}
}

Type模式匹配：

點選(此處)摺疊或開啟

def match_type(t : Any) = t match {
case p : Int => println("It is Integer")
case p : String => println("It is String, the content is : " + p)
case m: Map[_, _] => m.foreach(println)
case _ => println("Unknown type!!!")
}
match_type(2)
match_type("Spark")
match_type(Map("Scala" -> "Spark"))

結果：
It is Integer
It is String, the content is : Spark
(Scala,Spark)

Array模式匹配：

點選(此處)摺疊或開啟

def match_array(arr : Any) = arr match {
case Array(0) => println("Array:" + "0") //匹配Array只有1個元素，而且是0
case Array(x, y) => println("Array:" + x + " " +y) //匹配兩個元素
case Array(0, _*) => println("Array:" + "0 ...") //匹配至少1個元素，而且第一個元素是0
case _ => println("something else")
}
match_array(Array(0))
match_array(Array(1,2))
match_array(Array(0,1,2,3,4,5))

結果：
Array:0
Array:1 2
Array:0 ...

List模式匹配：

點選(此處)摺疊或開啟

def match_list(lst : Any) = lst match {
case 0 :: Nil => println("List:" + "0") //匹配List只有一個元素，而且是0
case x :: y :: Nil => println("List:" + x + " " + y) //匹配List有兩個元素
case 0 :: tail => println("List:" + "0 ...") //匹配List至少有一個元素，而且第一個元素是0
case _ => println("something else")
}
match_list(List(0))
match_list(List(3,4))
match_list(List(0,1,2,3,4,5))

結果：
List:0
List:3 4
List:0 ...

Tuple模式匹配：

點選(此處)摺疊或開啟

def match_tuple(tuple : Any) = tuple match {
case (0, _) => println("Tuple:" + "0") //匹配第一個元素是0，第二個任意
case (x, 0) => println("Tuple:" + x ) //匹配第一個元素任意，第二個元素是0
case _ => println("something else")
}
match_tuple((0,"Scala"))
match_tuple((2,0))
match_tuple((0,1,2,3,4,5))

結果：
Tuple:0
Tuple:2
something else

case class與case object模式匹配：

點選(此處)摺疊或開啟

abstract class Person
//每個case class都會有一個伴生物件，apply方法負責建立case class的例項
case class Student(age: Int) extends Person //預設宣告為val，不可變
case class Worker(age: Int, salary: Double) extends Person
case object Shared extends Person
object case_class_object {
def main(args: Array[String]){
//面向介面（Persion）
def caseOps(person: Person) = person match {
case Student(age) => println("I am " + age + "years old") //從傳進來的person物件中析取age值，構造新的Student物件，這個提取動作發生在伴生物件的unApply方法中
case Worker(_, salary) => println("Wow, I got " + salary)
case Shared => println("No property")
}
caseOps(Student(19))
caseOps(Shared)
val worker = Worker(29, 10000.1) //apply呼叫
val worker2 = worker.copy(salary = 19.95) //複製一個新的物件，並且重新賦值
val worker3 = worker.copy(age = 30)
}
}

用途：傳遞訊息與模式匹配，spark中worker與master進行通訊的時候，傳遞case class或者case object，接收訊息後再進行模式匹配。

巢狀case class的模式匹配：

點選(此處)摺疊或開啟

def main(args: Array[String]) {
def caseclass_nested(item: Item) = item match {
case Bundle(_, _, art @ Book(_, _), rest @ _*) => println(art.description + " : " + art.price) //使用@符號可以引用這個物件
case Bundle(_, _, Book(descr, _), _*) => println("The first description is :" + descr)
case _ => println("Oops!")
}
caseclass_nested(Bundle("1111 Special's", 30.0,
Book("Scala for the Spark Developer", 69.95),
Bundle("Hadoop", 40.0,
Book("Hive", 79.95),
Book("HBase", 32.95)
)
))
caseclass_nested(Bundle("1212 Special's", 35.0,
Book("Spark for the Impatient", 39.95)
))
}

Option的使用：

點選(此處)摺疊或開啟

sealed abstract class Option[+A] extends Product with Serializable

點選(此處)摺疊或開啟

final case class Some[+A](x: A) extends Option[A] {
def isEmpty = false
def get = x
}

點選(此處)摺疊或開啟

case object None extends Option[Nothing] {
def isEmpty = true
def get = throw new NoSuchElementException("None.get")
}

sealed：強制要求，Option下定義的的case class（Some）或者case object（None）都必須在同一個檔案中。

點選(此處)摺疊或開啟

def main(args: Array[String]){
val scores = Map("Alice" -> 99, "Spark" -> 100)
scores.get("Spark") match { //Map的get方法返回Option型別的值
case Some(score) => println(score)
//或者這樣：
case a @ Some(score) => println(a.get)
case None => println("No score")
}
}

模式匹配下的for迴圈
object For_Advanced {
def main(args: Array[String]): Unit = {
    for(i <- List(1,2,3,4,5) ) {println(i)}

    //變數繫結，給Flink設定別名，然後模式匹配值
    for(index@"Flink" <- List("Hadoop","Spark","Flink") ) {println(index)} //Flink

    //模式匹配具體的值
    for ((language,"Hadoop") <- Set("Scala"->"Spark","Java"->"Hadoop") ) println(language) //Java

    //模式匹配型別
    for((k,v:Int) <- List(("Spark"->5),("Hadoop"->"Big Data"))) {println(k)}
}
}

模式匹配下的賦值語句

點選(此處)摺疊或開啟

object Assinment_Internals {
def main(args: Array[String]) {
val a@b = 1000 //a是b別名，模式匹配後返回二元Tuple(a, b)
println("a = " + a + ", b = " + b)
val (c,d) = (1000,2000)
// val (e,F) = (1000,2000) //F大寫的話會把它當成常量，而常量未定義則會報錯
val Array(g,h) = Array(1000,2000)
// val Array(i,J) = Array(1000,2000)
// object Test { val 1 = 1 } //看傳進來的值是否匹配1
object Test { val 1 = 2 } //編譯器lazy匹配，所以編譯透過，但是執行報錯
}
}

Scala模式匹配

相關文章