scala 模式匹配

一.模式匹配

package com.jason.qianfeng

object PatternDemo {
  val url = "www.cnblogs.com/jason-dong"
  val CNBLOG = "www.cnblogs.com/jason-dong"
  val cnblog = "www.cnblogs.com"

  //字面量常量测试
  def p1 = url match {
    case "www.cnblogs.com" => println("cnblogs success")
    case "www.cnblogs.com/jason-dong" => println("jason dong success")
    case _ => println("fail")
  }

  //变量常量测试
  def p2 = url match {
    case CNBLOG => println("success")
    case _ => println("fail")
  }

  //变量模式匹配
  def p3 = url match {
    case cnblog => println(s"$cnblog success")
    case _ => println("fail")
  }

  //变量模式匹配2
  def p4 = url match {
    case `cnblog` => println(s"$cnblog success")
    case _ => println("fail")
  }

  val list = List(1,2,3)
  //通配符
  def p5 = list match {
    case List(_,_,3) =>println("success")
    case _ => println("fail")
  }
  def main(args: Array[String]): Unit = {
    println("==字面量常量测试 p1")
    p1
    println("==变量常量测试 p2")
    p2
    println("==变量模式匹配 p3")
    p3
    println("==变量模式匹配2 p4")
    p4
    println("==通配符")
    p5
  }

}

运行结果如下：

==字面量常量测试 p1
jason dong success
==变量常量测试 p2
success
==变量模式匹配 p3
www.cnblogs.com/jason-dong success
==变量模式匹配2 p4
fail
==通配符
success

小结：

1.scala 中的模式匹配类似java中的switch case，case _ 类似java中的 case:default ,scala一条匹配语句之后不用加 break；

2.字面量常量匹配会按照字面量的值进行匹配

3.变量常量(变量名为大写字母)同字面量常量

4.变量（变量名为小写）其实和case _ 是相同的，会把url的值赋给变量，若想让变量起到变量常量的效果，需要给变量加个壳，如p4（“·”是键盘上面1左侧的按键，并不是单引号“'”）

5.通配符：如配所示，case List(_,_,3)，标识第三个元素为3 ，前两个元素任意，此处"_" 为通配符

二.样例类模式匹配

package com.jason.qianfeng

abstract class MessageX

case class Email(sender: String, title: String, body: String) extends MessageX

case class SMS(caller: String, msg: String) extends MessageX

case class VoiceRecord(contactName: String, link: String) extends MessageX

object PatternDemo2 {
  //根据样例类进行模式匹配
  def getMsg(msg: MessageX): String = msg match {
    case Email(sender, title, body) => s"got a email from ${sender}"
    case SMS(caller, msg) => s"got a short message from ${caller}"
    case VoiceRecord(contactName, link) => s"got a voicerecord"
    case _ => "got a new message"
  }

  //带过滤器的模式匹配
  def getImportantMsg(msg: MessageX): String = msg match {
    case Email(sender, title, body) if title == "important" => s"got a email from ${sender}"
    case SMS(caller, msg) => s"got a short message from ${caller}"
    case VoiceRecord(contactName, link) => s"got a voicerecord"
    case _ => "got a new message"
  }

  def main(args: Array[String]): Unit = {
    val email = Email("jason", "meeting", "9:00 pm,302")
    println(s"==样例类模式匹配")
    val msg = getMsg(email)
    println(msg)
    println(s"==带过滤器的模式匹配")
    val msg2 = getImportantMsg(email)
    println(msg2)
  }
}

输出结果：

==样例类模式匹配
got a email from jason
==带过滤器的模式匹配
got a new message

三.类型匹配，根据变量的类型进行匹配

package com.jason.qianfeng

import scala.util.Random

object PatternDemo3 {
  val arr = Array("jason", 1, 3.14)
  val msg: (Any) => String = (a: Any) => a match {
    case x: Int => s"$x is a int"
    case x: String => s"$x is a string"
    case x: Double => s"$x is a double"
    case _ => s"type unknown"
  }

  def main(args: Array[String]): Unit = {
    for (i <- 1 to 3) {
      val a = arr(Random.nextInt(3))
      println(s"$a => ${msg(a)}")
    }
  }


}

运行结果：

1 => 1 is a int
1 => 1 is a int
jason => jason is a string