模式匹配的簡介
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中的第一、二個元素
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!!!")
}
}
}