scala模式匹配·

二、模式匹配应用
1、for循环控制结构中的模式匹配

object patternMatchingInForLoop extends App{for(x<-List(“Spark”,”Hive”,”Hadoop”))println(“普通for循环:”+x)for(x@”Spark”<- List(“Spark”,”Hive”,”Hadoop”))println(“变量绑定for循环：“+x)for((x,2)<-List((“Spark”,100),(“Hive”,2),(“Hadoop”,2)))println(“有十足模式匹配味道的for循环：“+x)}

执行结果：
普通for循环:Spark
普通for循环:Hive
变量绑定for循环：Hadoop
有十足模式匹配味道的for循环：Hive
有十足模式匹配味道的for循环：Hadoop

2、正则表达式中的模式表达式
正则表达式的基础知识：https://baike.baidu.com/item/%E6%AD%A3%E5%88%99%E8%A1%A8%E8%BE%BE%E5%BC%8F/1700215?fr=aladdin

匹配邮箱并提取邮箱名

object mailRegex{def main(args:Array[String])={val mailRegex=”([\\w-]+(\\.[\\w-]+)*)@[\\w-]+(\\.[\\w-]+)+”.rval mailStr=”如果有任何问题请联系：[e-mail]或联系[e-mail]“for(matchString<-mailRegex.findAllIn(mailStr)){println(matchString)}for(mailRegex(domainName,_*)<-mailRegex.findAllIn(mailStr)){println(domainName)}}}

3、异常处理中的模式匹配

import java.io.Fileimport java.io.IOExceptionobject scalaExceptionDemo extends App{val file:File=new File(“a.txt”)if(!file.exists){try{file.createNewFile}catch{case e:IOException=>{e.printStackTrace}}}}Scala语言中的模式匹配可以看作是对switch语句的改进，如例：

object patternMatching extends APP{
for(i<-1 to 100){
i match{
case 50=>println(i)
case 10=>println(i)
case_if(i%5==0)=>println(i+”能被5整除“)//if守卫条件
case _=>//相当于default;
}
}
}

模式匹配类型###1、   常量模式case后面接3、true、“test“、NULL等常量

object patternMatching extends APP{
def patternShow(x:Any)=i match{
case 50=>println(i)
case 10=>println(i)
case “test”=>println(“字符串“)
case Nil=>println(“空列表“)
case =>//相当于default;case 和之间有空格
}

}

###2、   变量模式case后接上变量###3、   构造器模式直接在case后接构造器语句，类被定义为case class

case class Person(name:String,age:Int)
object constructorPattern{
def main(args:Array[String]):Unit=
{
val p=new Person(“hyp”,18)
def constructorPattern(p:Person)=p match{
case Person(name,age)=>”name”+name+”,age”+age
case person(_,age)=>”age=”+age
case _=>”Other”
}
println(contructorPattern(p))
}
}

###4、   序列模式用于匹配数组，列表，range 等线性结构，原理也是case class

object sequencePattern{
def main(args Array[String]):Unit=
{
val list=List(“spark”,”Hive”,”SparkSQL”)
val arr=Array(“SparkR”,”Spark streaming”,”Spark MLlib”)
def sequencePattern(p:Any){
case Array(first,second,_*)=>first+”,”+second
case List(_,second,_*)=>second
case _=>”other”
}
println(sequencePattern(list))
}
}

###5、   元祖模式用于匹配元组模式的变量内容

object tuplePattern{
def main(args:Array[String]):Unit=
{
var t=(“Spark”,”hive”,”SparkSQL”)
def tuplePattern(t:Any)=t match{
case (one,,)=>one//_*只适用序列，不适用元祖
case _=>”other”
}
println(tuplePattern(t))
}
}

###6、   类型模式匹配输入待匹配变量的类型，

object typePattern{
def main(args:Array[String]);Unit={
def typePattern(t:Any)=t match{
case t:String=>”String”
case t:Int=>”Int”
case _=>”other Type”

}
println(typePattern(5))
}
}

也可使用类型判断实现上述用例

object typePattern2 externs APP{
def tuplePattern2(t:Any)={
if(t.isInstanceOf[String]) “String”
else if(t.isInstanceOf[Int]) “Int”
else if(t.isInstanceOf[Map[,]])”Map”
}
println(tuplePattern2(“5”))
}

不能匹配case _所能匹配的情况###7、   变量绑定模式将某个变量绑定到某个模式，将整体匹配结果赋值给该变量，使用方法：在模式前面加变量和@符号如下例：

object variableBindingPattern{
def main(args:Array[String])={
var t=List(List(1,2,3),List(2,3,4))
def variableBindingPattern(t:Any)=t match{
case List(,e@List(,,))=>e
case _=>Nil
}
println(variableBindingPatern(t))
}
}

执行结果为List(2,3,4)###8、   模式匹配与case class当一个类被声明为case class编译器会做如下操作：（1） 构造器参数默认为val类型（2） 自动创建伴生对象同时在伴生对象中实现apply方法，在使用时不用显式地使用new对象（3） 伴生对象中同样生成unapply方法，从而可以将case class 应用于模式匹配；（4） 实现自己的toString,hashCode,copy,equals,等方法

abstract class Person(name:String)
case class Student(name:String,age:Int,studentNo:Int) extends Person(name)
case class Teacher(name:String,Age:Int,teacherNo:Int)extends Person(name)
case class Nobody(name:String) extends Person(name)
object caseClassAndPatternMatching{
def main(args:Array[String])={
val p:person=Student(“xb”,18,1023)
p match{
case Student(name,age,studentTo)=>println(name+”:”+age+”:”+studentNo)
case Teacher(name,age,teacherNo)=>println(“teacher”+name+”:”+age+”:”+teacherNo)
case Nobody(name)=>println(name)
}
}
}
“`

sealed class ,如果没有将可能匹配的情况全部列举出来，将会给出警告
用法sealed abstract class person(name:String)