【版权声明】博客内容由厦门大学数据库实验室拥有版权，未经允许，请勿转载！
[返回Spark教程首页]
Java中有switch-case语句，但是，只能按顺序匹配简单的数据类型和表达式。相对而言，Scala中的模式匹配的功能则要强大得多，可以应用到switch语句、类型检查、“解构”等多种场合。
简单匹配
Scala的模式匹配最常用于match语句中。下面是一个简单的整型值的匹配实例。
val colorNum = 1
val colorStr = colorNum match {
case 1 => "red"
case 2 => "green"
case 3 => "yellow"
case _ => "Not Allowed"
}
println(colorStr)
为了测试上面代码，可以直接把上面代码放入到“/usr/local/scala/mycode/test.scala”文件中，然后，在Linux系统的Shell命令提示符状态下执行下面命令：
scala test.scala
另外，在模式匹配的case语句中，还可以使用变量。
val colorNum = 4
val colorStr = colorNum match {
case 1 => "red"
case 2 => "green"
case 3 => "yellow"
case unexpected => unexpected + " is Not Allowed"
}
println(colorStr)
按照前面给出的方法，在test.scala文件中测试执行上述代码后会在屏幕上输出：
4 is Not Allowed
也就是说，当colorNum=4时，值4会被传递给unexpected变量。
类型模式
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)
}
在test.scala文件中测试执行上述代码后会在屏幕上输出：
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.")
}
}
上面代码中if后面条件表达式的圆括号可以不要。执行上述代码后可以得到以下输出结果：
1 is odd.
2 is even.
3 is odd.
4 is even.
for表达式中的模式
我们之前在介绍“映射”的时候，实际上就已经接触过了for表达式中的模式。
还是以我们之前举过的映射为例子，我们创建的映射如下：
val university = Map("XMU" -> "Xiamen University", "THU" -> "Tsinghua University","PKU"->"Peking University")
循环遍历映射的基本格式是：
for ((k,v) <- 映射) 语句块
对于遍历过程得到的每个值，都会被绑定到k和v两个变量上，也就是说，映射中的“键”被绑定到变量k上，映射中的“值”被绑定到变量v上。
下面给出此前已经介绍过的实例：
for ((k,v) <- university) printf("Code is : %s and name is: %s\n",k,v)
上面代码执行结果如下：
Code is : XMU and name is: Xiamen University
Code is : THU and name is: Tsinghua University
Code is : PKU and name is: Peking University
case类的匹配
case类是一种特殊的类，它们经过优化以被用于模式匹配。
case class Car(brand: String, price: Int)
val myBYDCar = new Car("BYD", 89000)
val myBMWCar = new Car("BMW", 1200000)
val myBenzCar = new Car("Benz", 1500000)
for (car <- List(myBYDCar, myBMWCar, myBenzCar)) {
car match{
case Car("BYD", 89000) => println("Hello, BYD!")
case Car("BMW", 1200000) => println("Hello, BMW!")
case Car(brand, price) => println("Brand:"+ brand +", Price:"+price+", do you want it?")
}
}
把上述代码放入test.scala文件中，运行“scala test.scala”命令执行后可以得到如下结果：
Hello, BYD!
Hello, BMW!
Brand: Benz, Price:1500000, do you want it?
Option类型
标准类库中的Option类型用case类来表示那种可能存在、也可能不存在的值。
一般而言，对于每种语言来说，都会有一个关键字来表示一个对象引用的是“无”，在Java中使用的是null。Scala融合了函数式编程风格，因此，当预计到变量或者函数返回值可能不会引用任何值的时候，建议你使用Option类型。Option类包含一个子类Some，当存在可以被引用的值的时候，就可以使用Some来包含这个值，例如Some("Hadoop")。而None则被声明为一个对象，而不是一个类，表示没有值。
下面我们给出一个实例。
//首先我们创建一个映射
scala> val books=Map("hadoop"->5,"spark"->10,"hbase"->7)
books: scala.collection.immutable.Map[String,Int] = Map(hadoop -> 5, spark -> 10, hbase -> 7)
//下面我们从映射中取出键为"hadoop"对应的值，这个键是存在的，可以取到值，并且取到的值会被包含在Some中返回
scala> books.get("hadoop")
res0: Option[Int] = Some(5)
//下面我们从映射中取出键为"hive"对应的值，这个键是不存在的，所以取到的值是None对象
scala> books.get("hive")
res1: Option[Int] = None
Option类型还提供了getOrElse方法，这个方法在这个Option是Some的实例时返回对应的值，而在是None的实例时返回传入的参数。例如：
scala> val sales=books.get("hive")
sales: Option[Int] = None
scala> sales.getOrElse("No Such Book")
res3: Any = No Such Book
scala> println(sales.getOrElse("No Such Book"))
No Such Book
可以看出，当我们采用getOrElse方法时，如果我们取的"hive"没有对应的值，我们就可以显示我们指定的“No Such Book”，而不是显示None。
在Scala中，使用Option的情形是非常频繁的。在Scala里，经常会用到Option[T]类型，其中的T可以是Sting或Int或其他各种数据类型。Option[T]实际上就是一个容器，我们可以把它看做是一个集合，只不过这个集合中要么只包含一个元素（被包装在Some中返回），要么就不存在元素（返回None）。既然是一个集合，我们当然可以对它使用map、foreach或者filter等方法。比如：
scala> books.get("hive").foreach(println)
可以发现，上述代码执行后，屏幕上什么都没有显示，因为，foreach遍历遇到None的时候，什么也不做，自然不会执行println操作。
