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中的第一、二个元素
　　　　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!!!")
　　　　}
　　}

}