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-]+)+”.r
val mailStr=”如果有任何问题请联系：1610086859@126.com或联系xb1998@sina.com“
for(matchString<-mailRegex.findAllIn(mailStr))
{
println(matchString)
}
for(mailRegex(domainName,_*)<-mailRegex.findAllIn(mailStr))
{
println(domainName)
}
}
}

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

import java.io.File
import java.io.IOException
object 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)