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 应用于模式
4000
匹配；
（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)