Scala中的模式匹配的功能可以应用到switch语句、类型检查、“解构”等多种场合。

简单匹配

Scala的模式匹配最常用于match语句中。Scala的match语句类似Java里的switch。

匹配实例：

  def color(num: Int): String = {

    val colorNum = num

    val colorStr = colorNum match {

      case 1          => "red"

      case 2          => "green"

      case 3          => "yellow"

      //case _          => "Not Allowed"  //通配其他条件

      case unexpected => unexpected + " is Not Allowed" //可以在模式匹配的case语句中使用变量

    }

    s"$colorStr" //函数的返回值

  }                                               //> color: (num: Int)String

  color(1)                                        //> res0: String = red

  color(5)                                        //> res1: String = 5 is Not Allowed

类型模式

Scala可以对表达式的类型进行匹配。

  for (elem <- List(9, 12.3, "Spark", "Hadoop", 'Hello)) {

    val str = elem match {

      case i: Int    => i + " is an int value."

      case d: Double => d + " is a double value."

      case "Spark"   => "Spark is found."

      case s: String => s + " is a string value."

      case _         => "This is an unexpected value."

    }

    println(str)

  }                                               //> 9 is an int value.

                                                  //| 12.3 is a double value.

                                                  //| Spark is found.

                                                  //| Hadoop is a string value.

                                                  //| This is an unexpected value.

"守卫(guard)"语句

在模式匹配中添加一些必要的处理逻辑。

  for (elem <- List(1, 2, 3, 4)) {

    elem match {

      case _ if (elem % 2 == 0) => println(elem + " is even.")

      case _                    => println(elem + " is odd.")

    }                                             //> 1 is odd.

                                                  //| 2 is even.

                                                  //| 3 is odd.

                                                  //| 4 is even.

  }

for表达式中的模式

循环遍历映射的基本格式：for ((k,v) <- 映射) 语句块

映射中的“键”被绑定到变量k上，映射中的“值”被绑定到变量v上。

  val test = Map(111 -> "AAA", "22" -> "BB", '3' -> 'c')

                                                  //> test  : scala.collection.immutable.Map[Any,Any] = Map(111 -> AAA, 22 -> BB, 3

                                                  //|  -> c)

  for ((k, v) <- test) printf("Key is : %s and value is: %s\n", k, v)

                                                  //> Key is : 111 and value is: AAA

                                                  //| Key is : 22 and value is: BB

                                                  //| Key is : 3 and value is: c

case类的匹配

case类是一种特殊的类，ke以被用于模式匹配。

  case class Car(brand: String, price: Int)

  val myBMWCar = new Car("BMW", 1200000)          //> myBMWCar  : TestScala.Car = Car(BMW,1200000)

  val myBenzCar = new Car("Benz", 1500000)        //> myBenzCar  : TestScala.Car = Car(Benz,1500000)

  for (car <- List(myBMWCar, myBenzCar)) {

    car match {

      case Car("BMW", 1200000) => println("Hello, BMW!")

      case Car(brand, price)   => println("Brand:" + brand + ", Price:" + price + ", do you want it?")

    }                                             //> Hello, BMW!

                                                  //| Brand:Benz, Price:1500000, do you want it?

  }

Option类型

一般而言，每种语言都会有一个关键字来表示一个对象引用的是“无”，在Java中使用的是null。

而在Scala中，如果变量或者函数返回值可能不会引用任何值的时候，建议使用Option类型。

Option类的子类Some，当存在可以被引用的值的时候，可以使用Some来包含这个值
None则被声明为一个对象，而不是一个类，表示没有值。
Option类型的getOrElse方法，可以在Option是Some的实例时返回对应的值，是None的实例时返回传入的参数。

Option[T]类型

Option[T]类型中的T可以是Sting或Int或其他各种数据类型。
Option[T]实际是一个特殊的集合，要么只包含一个元素（被包装在Some中返回），要么就不存在元素（返回None）。
可以针对Option[T]使用map、foreach或者filter等集合的方法。

  val books = Map("AAA" -> 111, "BBB" -> 222, "CCC" -> 333)

                                                  //> books  : scala.collection.immutable.Map[String,Int] = Map(AAA -> 111, BBB ->

                                                  //|  222, CCC -> 333)

  books.get("AAA")                                //> res0: Option[Int] = Some(111)

  books.get("DDD")                                //> res1: Option[Int] = None

  val sales = books.get("BBB")                    //> sales  : Option[Int] = Some(222)

  books.get("BBB").getOrElse("No Such Book - BBB")//> res2: Any = 222

  books.get("DDD").getOrElse("No Such Book - DDD")//> res3: Any = No Such Book - DDD

  books.get("CCC").foreach(println)               //> 333

  books.get("DDD").foreach(println)

注意：

books.get("AAA") //Key存在，取到的value值被包含在Some中返回

books.get("DDD") //key不存在，取到的值是None对象

巴特西

Scala - 快速学习07 - 模式匹配