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语法,但是有更强大的match case语法,即类型匹配,类替代
//match case的语法如下:变量 match { case 值 => 代码 }。_代表不满足以上所有情况的默认。当有一个case分支满足了,就不会继续向下匹配了
//match case语法最基本的应用,就是对变量的值进行模式匹配
//案例:成绩评价
object demo1{
  def main(args: Array[String]):Unit={
    def studentScore(score:String):Unit={
      score match{
        case "a"=>println("优秀")
        case "b"=>println("良好")
        case "c"=>println("一般")
        case _=>println("继续努力")
      //_代表其他
      }
    }
    studentScore("a")  //优秀
  }
}

在模式匹配中使用if守卫

//scala模式匹配可以在case的条件判断后加上一个if,进行双重过滤
object demo1{
  def main(args: Array[String]):Unit={
    def studentScore(name:String,score:String):Unit={
      score match{
        case "a"=>println("优秀")
        case "b"=>println("良好")
        case "c"=>println("一般")
        case _ if name=="xiong"=>println(name+"是个好孩子,加油")
        case _=>println("继续努力")
      }
    }
    studentScore("xiong","d") //xiong是个好孩子,加油
  }
}

在模式匹配中进行变量赋值

//在进行case匹配值的时候,就只有这一个值(在这里是score),对于_(下划线)这种情况,即不满足以上所有情况的时候,都会进行默认的处理,此时我们可以使用变量赋值的方法在处理语句中加入这个值
object demo1{
  def main(args: Array[String]):Unit={
    def studentScore(name:String,score:String):Unit={
      score match{
        case "a"=>println("优秀")
        case "b"=>println("良好")
        case "c"=>println("一般")
        case _ if name=="xiong"=>println(name+"是个好孩子,加油")
        case _score=>println(name+"要努力呀,你的成绩才为"+_score) //变量赋值
      }
    }
    studentScore("zhangSan","d") //zhangSan要努力呀,你的成绩才为d
  }
}

2、对类型进行模式匹配

//scala可以直接匹配类型,而不是值
//语法 case 变量:类型 => 代码 与上面有一些细微差别
//案例:异常处理
object demo1{
  def main(args: Array[String]):Unit={
    import java.io._
    def processException(e:Exception):Unit={
      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())
  }
}

3、对Array和List的元素进行模式匹配

//对Array进行模式匹配,分别可以匹配带有指定元素的数组、带有指定个数的数组、以某元素开头的数组
//对List进行模式匹配,与Array类似,但是需要使用List特有的::操作符

//案列:对朋友打招呼
object demo1{
  def main(args: Array[String]):Unit={
    def greeting(arr:Array[String]):Unit={
      arr match{
        case Array("Leo")=>println("Hi,Leo!") //匹配一个元素
        case Array(a,b,c)=>println("Hi,"+a+","+b+","+c) //匹配三个元素
        case Array("Leo",_*)=>println("Hi,Leo,please introduce your friends to me.") //匹配Leo开头的数组
        case _=>println("Hey,who are you?")
      }
    }
    greeting(Array("Leo")) //Hi,Leo!
    greeting(Array("Leo","Jack","Bob")) //Hi,Leo,Jack,Bob
    greeting(Array("Leo","Jack","Bob","Alice")) //Hi,Leo,please introduce your friends to me.
    greeting(Array("Jack","Bob","Alice","Leo")) //Hey,who are you?
  }
}

//List
object demo1{
  def main(args: Array[String]):Unit={
    def greeting(list: List[String]){
      list match{
        case "Leo"::Nil=>println("Hi,Leo!")
        case "a"::"b"::"c"::Nil=>println("Hi,"+a+","+b+","+c) 
        case "Leo"::tail=>println("Hi,Leo,please introduce your friends to me.")
        case _=>println("Hey,who are you?")
      }
    }
    greeting(List("Leo")) //Hi,Leo!
    greeting(List("Leo","Jack","Bob")) //Hi,Leo,Jack,Bob
    greeting(List("Leo","Jack","Bob","Alice")) //Hi,Leo,please introduce your friends to me.
    greeting(List("Jack","Bob","Alice","Leo")) //Hey,who are you?
  }
}

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,age:Int) extends Person
case class Worker(name:String,work:String) extends Person
case class Stranger() extends Person
object demo1{
  def main(args: Array[String]):Unit={
    def entranceGuard(p:Person):Unit={
      p match{
        case Teacher(name,subject)=>println(s"Hello,$name,your teach is $subject")
        case Student(name,age)=>println(s"Hello,$name,your age is $age")
        case Worker(name,work) if work=="cleanner"==>println(s"Hello,$name,your work is $work")
        case Worker(name,work)=>println(s"Hello,$name,your work is $work,you should leavl 1 to 2 hours")
        case Stranger()=>println("stranger,you should leave right now")
      }
    }
    entranceGuard(Worker("Bob","cleanner"))
  }
}

Option与模式匹配

//Scala有一种特殊的类型,叫做Option。Option有两种值,一种是Some,表示有值,一种是None,表示没有值。
// Option通常会用于模式匹配中,用于判断某个变量是有值还是没有值,这比null来的更加简洁明了
// Option的用法必须掌握,因为Spark源码中大量地使用了Option,比如Some(a)、None这种语法,因此必须看得懂Option模式匹配,才能够读懂spark源码。

//案例:成绩评价
object demo1{
  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 is not in this system")
      }
    }
    getGrade("Leo") //your grade is a
    getGrade("J") // Sorry, your grade is not in this system
  }
}
©️2020 CSDN 皮肤主题: 深蓝海洋 设计师:CSDN官方博客 返回首页