快学Scala第14章----模式匹配和样例类

Posted 大冰的小屋

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了快学Scala第14章----模式匹配和样例类相关的知识,希望对你有一定的参考价值。

本章要点

  • match表达式是一个更好的switch,不会有意外掉入到下一个分支的问题。
  • 如果没有模式能够匹配,会抛出MatchError。可以用case _ 模式来避免。
  • 模式可以包含一个随意定义的条件,称作守卫。
  • 你可以对表达式的类型进行匹配;优先选择模式匹配而不是isInstanceOf/asInstanceOf。
  • 你可以匹配数组、元组和样例类的模式,然后将匹配到的不同部分绑定到变量。
  • 在for表达式中,不能匹配的情况会被安静的跳过。
  • 样例类继承层级中的公共超类应该是sealed的。
  • 用Option来存放对于可能存在也可能不存在的值—-这比null更安全。

更好的switch

以下是Scala中C风格switch语句的等效代码:

var sign = ...
val ch: Char = ...

ch match {
  case '+' => sign = 1
  case '-' => sign = -1
  case _ => sign = 0
}

在这里,case _ 与 C 语言的 default 相同,可以匹配任意的模式,所以要注意放在最后。C 语言的 switch中的case语句必须使用break才能推出当前的分支,否则会继续执行后面的分支,直到遇到break或者结束; 而Scala的模式匹配只会匹配到一个分支,不需要使用break语句,因为它不会掉入到下一个分支。
match是表达式,与if一样,是有值的:

sign = ch match {
  case '+' => 1
  case '-' => -1
  case _ => 0
}

守卫

在C语言中,如果你想用switch判断字符是数字,则必须这么写:

switch(ch) {
  case '0':
  case '1':
  case '2':
  case '3':
  ...
  case '8':
  case '9': do something; break;
  default: ...; 
}

你要写10条case语句才可以匹配所有的数字;而在Scala中,你只需要给模式添加守卫:

ch match {
  case '+' => 1
  case '-' => -1
  case _ if Character.isDigit(ch) => digit = Character.digit(ch, 10)
  case _ => 0
}

模式匹配中的变量

如果case关键字后面跟着一个变量名,那么匹配的表达式会被赋值给那个变量。

str(i) match {
  case '+' => 1
  case '-' => -1
  case ch => digit = Character.digit(ch, 10)
}

// 在守卫中使用变量
str(i) match {
  case ch if Character.isDigit(ch) => digit = Character.digit(ch, 10)
  ...
}

**注意: **Scala是如何在模式匹配中区分模式是常量还是变量表达式: 规则是变量必须是以小写字母开头的。 如果你想使用小写字母开头的常量,则需要将它包在反单引号中。
这里写图片描述


类型模式

你可以对表达式的类型进行匹配,例如:

obj match {
  case x: Int => x
  case s: String => Integer.parseInt(s)
  case _: BigInt => Int.MaxValue
  case - => 0
}

在Scala中我们会优先选择模式匹配而不是isInstanceOf/asInstanceOf。
注意: 当你在匹配类型的时候,必须给出一个变量名,否则你将会拿对象本身来进行匹配:

obj match {
  case _: BigInt => Int.MaxValue  // 匹配任何类型为BigInt的对象
  case BigInt => -1              // 匹配类型为Class的BigInt对象
}

注意: 匹配发生在运行期,Java虚拟机中泛型的类型信息是被擦掉的。因此,你不能用类型来匹配特定的Map类型。

case m: Map[String, Int] => ...   // error
// 可以匹配一个通用的映射
case m: Map[_, _] => ...   // OK

// 但是数组作为特殊情况,它的类型信息是完好的,可以匹配到Array[Int]
case m: Array[Int] => ...   // OK

匹配数组、列表和元组

要匹配数组的内容,可以在模式中使用Array表达式:

arr match {
  case Array(0) => "0"                  // 任何包含0的数组
  case Array(x, y) => x + " " + y   // 任何只有两个元素的数组,并将两个元素本别绑定到变量x 和 y
  case Array(0, _*) => "0 ..."         // 任何以0开始的数组
  case _ => "Something else"
}

同样也可以应用到List

lst match {
  case 0 :: Nil => "0"
  case x :: y :: Nil => x + " " + y
  case 0 :: tail => "0 ..."
  case _ => "Something else"
}

对于元组:

pair match {
  case (0, _) => "0, ..."
  case (y, 0) => y + " 0"
  case _ => "neither is 0"
}

提取器

在上面的模式是如何匹配数组、列表、元组的呢?Scala是使用了提取器机制—-带有从对象中提取值的unapply 或 unapplySeq方法的对象。其中, unapply方法用于提取固定数量的对象;而unapplySeq提取的是一个序列,可长可短。

arr match {
  case Array(0, x) => ...  // 匹配有两个元素的数组,其中第一个元素是0,第二个绑定给x
}

Array伴生对象就是一个提取器—-它定义了一个unapplySeq方法。该方法执行时为:Array.unapplySeq(arr) 产出一个序列的值。第一个值于0进行比较,第二个赋值给x。
正则表达式也可以用于提取器的场景。如果正则表达式有分组,可以用模式提取器来匹配每个分组:

val pattern = "([0-9]+) ([a-z]+)".r
"99 bottles" match {
  case pattern(num, item) => ...   // 将num设为99, item设为"bottles"
}

注意: 在这里提取器并不是一个伴生对象,而是一个正则表达式对象。


变量声明中的模式

在变量声明中也可以使用变量的模式匹配:

val (x, y) = (1, 2)  // 把x定义为1, 把y定义为2.
val (q, r) = BigInt(10) /% 3   // 匹配返回对偶的函数

// 匹配任何带有变量的模式
val Array(first, second, _*)  = arr  

for表达式中的模式

你可以在for推导式中使用带变量的模式。

import scala.collection.JavaConversions.propertiesAsScalaMap
for ((k, v) <- system.getProperties()) {
  println(k + " -> " + v)
}

在for推导式中,失败的匹配将被安静的忽略。例如:

// 只匹配值为空的情况
for ((k, "") <- system.getProperties()) {
  println(k)
}

// 也可以使用守卫
for ((k, v) <- system.getProperties() if v == "") {
  println(k)
}

样例类

样例类是一种特殊的类,它们经过优化以被用于模式匹配。

abstract class Amount
case class Dollar(value; Double) extends Amount
case class Currency(value: Double, unit: String) extends Amount

// 针对单例的样例对象
case object Nothing extends Amount

// 将Amount类型的对象用模式匹配来匹配到它的类型,并将属性值绑定到变量:
amt match {
  case Dollar(v) => "$" + v
  case Currency(_, u) => "Oh noes, I got " + u
  case Nothing => ""
}

当你声明样例类时,如下事情会自动发生:
- 构造器中每一个参数都成为val—-除非它被显示的声明为var(不建议这样做)
- 在伴生对象中提供apply方法让你不用new关键字就能够构造出相应的对象,例如Dollar(2)或Currency(34, “EUR”)
- 提供unapply方法让模式匹配可以工作
- 将生成toString、equals、hashCode和copy方法—-除非你显示的给出这些方法的定义。


copy方法和带名参数

样例类的copy方法创建一个与现有对象值相同的新对象。例如:

val amt = Currency(29.95, "EUR")
val price = amy.copy()    // Currency(29.95, "EUR")
val price2 = amt.copy(value = 19.95)  // Currency(19.95, "EUR")
val price3 = amt.copy(unit = "CHF")    // Currency(29.95, "CHF")

case语句中的中置表示法

如果unapply方法产出一个对偶,则可以在case语句中使用中置表示法。尤其是对于两个参数的样例类,你可以使用中置表示法来表示它。

amt match { case a Currency u => ... }  // 等同于 case Currency(a, u)

这个特性的本意是要匹配序列。例如:每个List对象要么是Nil,要么是样例类::, 定义如下:

case class ::[E](head: E, tail: List[E]) extends List[E]
// 因此你可以这么写
lst match {
  case h :: t => ...   // 等同于 case ::(h, t), 将调用::.unapply(lst)
}

匹配嵌套结构

样例类经常被用于嵌套结构。例如:商店售卖的商品:

abstract class Item
case class Article(description: String, price: Double) extends Item
case class Bundle(description: String, discount: Double, items: Item*) extends Item

// 产生嵌套对象
Bundle("Father's day special", 20.0, Article("Scala for the Impatient", 39.95), 
  Bundle("Anchor Distillery Sampler", 10.0, Article("Old Potrero Straight Rye Whisky", 79.95),
    Article("Junipero Gin", 32.95)))

// 模式匹配到特定的嵌套,比如:
case Bundle(_, _, Article(descr, _), _*) => ... 

上述代码将descr绑定到Bundle的第一个Article的描述。你也可以@表示法将嵌套的值绑定到变量:

case Bundle(_, _, art @ Article(_, _), rest @ _*) => ...

这样,art就是Bundle中的第一个Article, 而rest则是剩余Item的序列。 _*代表剩余的Item。
该特性实际应用:

def price(it: Item): Double = it match {
  case Article(_, p) => p
  case Bundle(_, disc, its @ _*) => its.map(price _).sum - disc
}

样例类是邪恶的吗

样例类适用于那种标记了不会改变的结构。例如Scala的List就是用样例类实现的。

abstract class List
case object Nil extends List
case class ::(head: Any, tail: List) extends List

当用在合适的地方时,样例类是十分便捷的,原因如下:
- 模式匹配通常比继承更容易把我们引向更精简的代码。
- 构造时不需要用new的符合对象更加易读
- 你将免费获得toString、equals、hashCode和copy方法。
对于样例类:

case class Currency(value: Double, unit: String)

一个Currency(10, “EUR”)和任何其他Currency(10, “EUR”)都是等效的,这也是equals和hashCode方法实现的依据。这样的类通常都是不可变的。对于那些带有可变字段的样例类,我们总是从那些不会改变的字段来计算和得出其哈希值,比如用ID字段。


密封类

密封类是指用sealed修饰的类。密封类的所有子类都必须在与该密封类相同的文件中定义。这样做的好处是:当你用样例类来做模式匹配时,你可以让编译器确保你已经列出了所有可能的选择,编译器可以检查模式语句的完整性。

sealed abstract class Amount
case class Dollar(value: Double) extends Amount
case class Currency(value: Double, unit: String) extends Amunt

上述的样例类必须与Amount类在一个文件中。


模拟枚举

sealed abstract class TrafficLightColor
case object Red extends TrafficLightColor
case object Yellow extends TrafficLightColor
case object Green extends TrafficLightColor

color match {
  case Red => "stop"
  case Yellow => "hurry up"
  case Green => "go"
}

Option类型

标准库中的Option类型用样例类来表示那种可能存在、也可能不存在的值。样例子类Some包装了某个值,例如: Some(“Fred”). 而样例对象None表示没有值。这比使用空字符串的意图更加清晰,比使用null来表示缺少的值的做法更安全。
Option支持泛型,例如:Some(“Fred”) 的类型是Option[String]。
Map的get方法返回一个Option。如果对于给定的键没有对应的值,则get返回None,如果有值,就会将该值包在Some中返回。

scores.get("Alice") match {
  case Some(score) => println(score)
  case None => println("No score")
}

//  可以使用isEmpty 和 get 替代上面代码
val aliceScore = scores.get("Alice")
if (aliceScore.isEmpty) println("No score")
else println(aliceScore.get)

// 使用更简便的 getOrElse方法
println(aliceScore.getOrElse("No score"))

偏函数

被包在花括号内的一组case语句是一个偏函数—-一个并非对所有输入值都有定义的函数。它是PartialFunction[A, B]类的一个实例。其中A是参数类型,B是返回类型。该类有两个方法:apply从匹配到的模式计算函数值, 而isDefinedAt方法在输入至少匹配其中一个模式时返回true。

val f: PartialFunction[Char, Int] = { case '+' => 1; case '-' => -1 }
f('-')   // 调用 f.apply('-'), 返回-1
f.isDefinedAt('0')  // fase
f('0')  // 抛出MatchError

有一些方法接受PartialFunction作为参数。例如 GenTraversable特质的collect方法将一个偏函数应用到所有该偏函数有定义的元素,并返回包含这些结果的序列:

"-3+4".collect {case '+' => 1;  case '-' => -1 }  // Vector(-1, 1)

这里写图片描述

以上是关于快学Scala第14章----模式匹配和样例类的主要内容,如果未能解决你的问题,请参考以下文章

必会Scala之模式匹配和样例类

Scala笔记整理:模式匹配和样例类

好程序员大数据教程分享Scala系列之模式匹配和样例类

Scala——(继承,特质,模式匹配和样例类)

从零学scala集合模式匹配和样例类

第3节 Scala中的模式匹配:1 - 5