2020.10.22课堂笔记(scala匹配模式)

模式匹配是Scala中非常有特色，非常强大的一种功能。模式匹配，其实类似于Java中的swich case语法，即对一个值进行条件判断，然后针对不同的条件，进行不同的处理。

但是Scala的模式匹配的功能比Java的swich case语法的功能要强大地多，Java的swich case语法只能对值进行匹配。但是Scala的模式匹配除了可以对值进行匹配之外，还可以对类型进行匹配、对Array和List的元素情况进行匹配、对case class进行匹配、甚至对有值或没值（Option）进行匹配。

而且对于Spark来说，Scala的模式匹配功能也是极其重要的，在spark源码中大量地使用了模式匹配功能。因此为了更好地编写Scala程序，并且更加通畅地看懂Spark的源码，学好模式匹配都是非常重要的。

1、模式匹配的基础语法（案例：成绩评价）

// Scala是没有Java中的switch case语法的，相对应的，Scala提供了更加强大的match case语法，即模式匹配，类替代switch case，match case也被称为模式匹配 // Scala的match case与Java的switch case最大的不同点在于，Java的switch case仅能匹配变量的值，比1、2、3等；而Scala的match case可以匹配各种情况，比如变量的类型、集合的元素、有值或无值 // match case的语法如下：变量 match { case 值 => 代码 }。如果值为下划线，则代表了不满足以上所有情况下的默认情况如何处理。此外，match case中，只要一个case分支满足并处理了，就不会继续判断下一个case分支了。（与Java不同，java的switch case需要用break阻止） // match case语法最基本的应用，就是对变量的值进行模式匹配 object test{ def main(args: Array[String]): Unit = { def studentScore(score:String): Unit ={ score match { case "A"=>println("excellent") case "B"=>println("good") case "C"=>println("soso") case _ =>println("you need work harder") } } studentScore("D") } } 在模式匹配中使用if守卫 // Scala的模式匹配语法，有一个特点在于，可以在case后的条件判断中，不仅仅只是提供一个值，而是可以在值后面再加一个if守卫，进行双重过滤 // 案例：成绩评价（升级版） object test{ def main(args: Array[String]): Unit = { def studentScore(name:String,score:String): Unit ={ score match { case "A"=>println("excellent") case "B"=>println("good") case "C"=>println("soso") case _ if name=="leo"=>print(name+",you are good boy,come on!")//if守卫 case _ =>println("you need work harder") } } studentScore("leo","D") } } 在模式匹配中进行变量赋值 // Scala的模式匹配语法，有一个特点在于，可以将模式匹配的默认情况，下划线，替换为一个变量名，此时模式匹配语法就会将要匹配的值赋值给这个变量，从而可以在后面的处理语句中使用要匹配的值 // 为什么有这种语法？？思考一下。因为只要使用用case匹配到的值，是不是我们就知道这个只啦！！在这个case的处理语句中，是不是就直接可以使用写程序时就已知的值！ // 但是对于下划线_这种情况，所有不满足前面的case的值，都会进入_这种默认情况进行处理，此时如果我们在处理语句中需要拿到具体的值进行处理呢？那就需要使用这种在模式匹配中进行变量赋值的语法！！ object test{ def main(args: Array[String]): Unit = { def studentScore(name:String,score:String): Unit ={ score match { case "A"=>println("excellent") case "B"=>println("good") case "C"=>println("soso") case _ if name=="leo"=>print(name+",you are good boy,come on!") case _score =>println("you need work harder,your score only "+_score) //变量赋值 } } studentScore("le","F") } }

2、对类型进行模式匹配（案例：异常处理）

// Scala的模式匹配一个强大之处就在于，可以直接匹配类型，而不是值！！！这点是java的switch case绝对做不到的。 // 理论知识：对类型如何进行匹配？其他语法与匹配值其实是一样的，但是匹配类型的话，就是要用“case 变量: 类型 => 代码”这种语法，而不是匹配值的“case 值 => 代码”这种语法。 // 案例：异常处理 object test{ def main(args: Array[String]): Unit = { import java.io._ def processException(e: Exception) { e match { case e1: IllegalArgumentException => println("you have illegal arguments! exception is: " + e1) case e2: FileNotFoundException => println("cannot find the file you need read or write!, exception is: " + e2) case e3: IOException => println("you got an error while you were doing IO operation! exception is: " + e3) case _: Exception => println("cannot know which exception you have!" ) } } processException(new IOException("not such file")) } }

3、对Array和List的元素进行模式匹配（案例：对朋友打招呼）

// 对Array进行模式匹配，分别可以匹配带有指定元素的数组、带有指定个数元素的数组、以某元素打头的数组 // 对List进行模式匹配，与Array类似，但是需要使用List特有的::操作符 // 案例：对朋友打招呼 object test{ def main(args: Array[String]): Unit = { def greeting(arr: Array[String]) { arr match { case Array("Leo") => println("Hi, Leo!") //匹配一个元素 case Array(girl1, girl2, girl3) => println("Hi, girls, nice to meet you. " + girl1 + " and " + girl2 + " and " + girl3) //匹配三个元素 case Array("Leo", _*) => println("Hi, Leo, please introduce your friends to me.") //匹配以Leo开头，三个元素会被上面匹配scala匹配机制是匹配到就停止 case _ => println("hey, who are you?") } } greeting(Array("Leo","lily","poly","jack")) } } //list object test{ def main(args: Array[String]): Unit = { def greeting(list: List[String]) { list match { case "Leo" :: Nil => println("Hi, Leo!") case girl1 :: girl2 :: girl3 :: Nil => println("Hi, girls, nice to meet you. " + girl1 + " and " + girl2 + " and " + girl3) case "Leo" :: tail => println("Hi, Leo, please introduce your friends to me.") case _ => println("hey, who are you?") } } greeting(List("Leo","jack","poly","herry")) } }

4、case class与模式匹配（案例：学校门禁）

// Scala中提供了一种特殊的类，用case class进行声明，中文也可以称作样例类。case class其实有点类似于Java中的JavaBean的概念。即只定义field，并且由Scala编译时自动提供getter和setter方法，但是没有method。 // case class的主构造函数接收的参数通常不需要使用var或val修饰，Scala自动就会使用val修饰（但是如果你自己使用var修饰，那么还是会按照var来） // Scala自动为case class定义了伴生对象，也就是object，并且定义了apply()方法，该方法接收主构造函数中相同的参数，并返回case class对象 // 案例：学校门禁 class Person case class Teacher(name:String,subject:String) extends Person case class Student(name:String,classroom:Int) extends Person case class Worker(name:String,work:String) extends Person case class Stranger() extends Person object test{ def main(args: Array[String]): Unit = { def entranceGuard(p:Person): Unit ={ p match { case Student(name,classroom)=>println(s"hello,$name,welcome to school,your classroom is $classroom") case Teacher(name,subject)=>println(s"hello,$name,welcome to school,your teach $subject") case Worker(name,work) if work=="repairman"=>println(s"hello,$name,you should leave school afternoon") case Worker(name,work)=>println(s"hello,$name,you should leave school 2 hours later") case _=>println(s"stranger,you can not into school") } } entranceGuard(Worker("Jason","cleaner")) } }

5、Option与模式匹配（案例：成绩查询）

// Scala有一种特殊的类型，叫做Option。Option有两种值，一种是Some，表示有值，一种是None，表示没有值。 // Option通常会用于模式匹配中，用于判断某个变量是有值还是没有值，这比null来的更加简洁明了 // Option的用法必须掌握，因为Spark源码中大量地使用了Option，比如Some(a)、None这种语法，因此必须看得懂Option模式匹配，才能够读懂spark源码。 object test{ def main(args: Array[String]): Unit = { val grades = Map("Leo" -> "A", "Jack" -> "B", "Jen" -> "C") def getGrade(name: String) { val grade = grades.get(name) grade match { case Some(grade) => println("your grade is " + grade) case None => println("Sorry, your grade information is not in the system") } } getGrade("J") } }

练习：

传递一个参数，A打印very good,B打印good,C打印just soso,使用守护,aaa打印good boy,其余打印study bad

object demoMatch { def match4(x:String):Unit=x match{ case "A" =>println("very good") case "B" =>println("good") case "C" => println("just soso") case _ if x=="aaa" =>println("good boy") case _ =>println("study bad") } def main(args: Array[String]): Unit = { match4("aaa") } }

在匹配模式中使用已定义的变量+在模式匹配中进行变量赋值：

https://stackoverflow.com/questions/7078022/why-does-pattern-matching-in-scala-not-work-with-variables

object demoMatch { def metch5(name:String,score:String):Unit={ val target:String="A" score match{ case `target` => println("very good study") case "B" => println("good study") case "C" => println("just soso") case _ if name=="bonb" => println("good boy") case _score => println("you must study hard, your score is "+ _score) } //在模式匹配中进行变量赋值 } def main(args: Array[String]): Unit = { metch5("zhangsan","A") } }

match 的必须是 stable identifier ，如果要使用已定义的变量，可以加反引号或者使用大写字母开头的变量。

// Scala的模式匹配语法，有一个特点在于，可以将模式匹配的默认情况，下划线，替换为一个变量名，此时模式匹配语法就会将要匹配的值赋值给这个变量，从而可以在后面的处理语句中使用要匹配的值 // 为什么有这种语法？？思考一下。因为只要使用用case匹配到的值，是不是我们就知道这个值啦！！在这个case的处理语句中，是不是就直接可以使用写程序时就已知的值！ // 但是对于下划线_这种情况，所有不满足前面的case的值，都会进入_这种默认情况进行处理，此时如果我们在处理语句中需要拿到具体的值进行处理呢？那就需要使用这种在模式匹配中进行变量赋值的语法！！

异常处理

import java.io.FileNotFoundException object demoMatch { def match6(e:Exception):Unit={ e match { case e1:IndexOutOfBoundsException => println("IndexOutOfBoundsException") case e2:FileNotFoundException => println("FileNotFoundException") case e3:NullPointerException => println("NullPointerException") case _:Exception => println("Exception") } } def main(args: Array[String]): Unit = { match6(new FileNotFoundException()) } }

传递不同的参数匹配不同的结果

object demoMatch { def match7(arr:Array[String]):Unit={ arr match { case Array("KB09") => println("hello KB09") case Array(girl1,girl2,girl3) => println(s"hello $girl1,$girl2,$girl3") case Array("KB09",_*)=>println("hello KB09*") case _=> println("who are you?") } } def main(args: Array[String]): Unit = { var arr=Array("KB09","KB07","KB05","KB02") //hello KB09* var arr1=Array("KB09") //hello KB09 var arr2=Array("KB09","KB07","KB05") //hello KB09,KB07,KB05 var arr3=Array("KB07","KB05","KB02","KB09") //who are you? match7(arr) match7(arr1) match7(arr2) match7(arr3) } }

打印结果：

hello KB09* hello KB09 hello KB09,KB07,KB05 who are you?

匹配不同的子类：

object demoMatch { class Person case class Teacher(name:String,age:Int) extends Person case class Student(name:String,age:Int) extends Person case class Worker(name:String,age:Int) extends Person case class msr(name:String,age:Int) extends Person def match8(p:Person):Unit={ p match{ case Teacher("zs",21) => println("zs 年龄为21岁的老师找到了") case Teacher("zs",age) => println("zs老师的年龄为："+age) case p1:Teacher=> println(p1.name+" "+p1.age) case p2:Student=> println(p2.name+""+p2.age) case p3:Worker if p3.name=="repairWorker" => println("修理工") case p4:Worker => println("普通工人") case _=>println("不熟悉，不知道什么人") } } def main(args: Array[String]): Unit = { val p1=Worker("zhangsan",21) val p2=Worker("repairWorker",19) val p3=Teacher("zs",23) val p4=Teacher("zs",21) match8(p1) //普通工人 match8(p2) //修理工 match8(p3) //zs老师的年龄为：23 match8(p4) //zs 年龄为21岁的老师找到了 } }

匹配option类型，Some和None

object demoMatch { val map=Map("zs"->"a","ls"->"b","ww"->"c") def match9(name:String):Unit={ var score=map.get(name) score match{ case Some(score) => println(name+"的成绩为"+score) case None => println("没有"+name+"对应的成绩") } } def main(args: Array[String]): Unit = { match9("zs") //zs的成绩为a match9("pq") //没有pq对应的成绩 } }