11. case classes 以及模式匹配
11.1 case class
a:在class 前面加上case ,该class 就成为了case class
b:scala 编译器 首先为 这个类添加了一个工厂方法 用来 构造对象 ,
这样允许 用户 不用使用new 就能构造对象
例如:
Java代码
- case class Var(name: String)
- scala> val v = Var("x")
- v: Var = Var(x)
c:在参数列表中的所有参数都隐含为val,因此 这些参数可以作为 字段加以维护
d:编译器为默认该类添加toString,hashcode equals 方法
e: 编译器为 该类 添加一个copy 方法,返回一个可以修改的copy 对象
11.2 pattern matching 模式匹配
a:定义模式匹配函数
selector match { alternatives }
每个alternatives 都是以case 开始
每个alternatives 都包含 模式 以及表达式,,其中=> 将表达式和模式给分离出来
b:例如:
Java代码
- def simplifyTop(expr: Expr): Expr = expr match {
- case UnOp("-", UnOp("-", e))
- => e
- // Double negation
- case BinOp("+", e, Number(0)) => e // Adding zero
- case BinOp("*", e, Number(1)) => e // Multiplying by one
- case _ => expr
- }
c: 1.在scala 中match 是一个表达式
2.在scala 中匹配一个pattern ,执行相关的expression,
但是不会执行到 下一个case
3.如果不能匹配到任何一个模式,则会抛出 MatchError 异常
4. 因此 需要为case 定义一个默认 default case ,该case 什么也不处理
例如:
Java代码
- expr match {
- case BinOp(op, left, right) =>
- println(expr +" is a binary operation")
- case _ =>
}
11.3 各种模式
a:_ 通配符匹配任何对象
b:constants pattern 常量模式:
使用常量值作为模式串,例如:
Java代码
- def describe(x: Any) = x match {
- case 5 => "five"
- case true => "truth"
- case "hello" => "hi!"
- case Nil => "the empty list"
- case _ => "something else"
- }
c:variable pattern 变量模式
1.变量模式 就像通配符_一样,匹配任何对象
2.和同配符_不一样的是,变量和任何对象绑定在一起 ,你可以使用这些变量就像object 一样
例如:
Java代码
- expr match {
- case 0 => "zero"
- case somethingElse => "not zero: "+ somethingElse
- }
d:构造对象模式
对象模式支持 多层的对象构造,也就是 deep match,例如:
Java代码
- expr match {
- case BinOp("+", e, Number(0)) => println("a deep match")
- case _ =>
- }
e:sequence 模式
1.匹配List 或者Array 这样的顺序类型
2.使用相同的case 语法,但是可以指定模式了的元素个数,
例如:
Java代码
- expr match {
- case List(0, _, _) => println("found it")
- case _ =>
- }
- 匹配列表中的前三个元素
3.使用_* 匹配任何长度的元素 ,例如:
Java代码
- expr match {
- case List(0, _*) => println("found it")
- case _ =>
- }
- 与list 中的第0个元素匹配,而不管这个List 有多长
e:Tuple pattern
例如:
Java代码
- def tupleDemo(expr: Any) =
- expr match {
- case (a, b, c)
- =>
- println("matched "+ a + b + c)
- case _ =>
- }
- scala> tupleDemo(("a ", 3, "-tuple"))
- matched a 3-tuple
f:Typed Pattern
1.方便做类型测试和类型转换
2.Map[_, _] 类型 在运行时,内部的类型会被同一转成 Object , 因此会碰到类型擦除的问题
3.但是Array[String] Array[Int]由于 在运行其使用的的底层机制是 String[] 或者int[] 类型,因此不会出现类型擦除的问题
例如:
Java代码
- def generalSize(x: Any) = x match {
- case s: String => s.length
- case m: Map[_, _] => m.size
- case _ => -1
- }
Java代码
- def isIntIntMap(x: Any) = x match {
- case m: Map[Int, Int] => true
- case _ => false
- }
- scala> isIntIntMap(Map(1 -> 1))
- res19: Boolean = true
- scala> isIntIntMap(Map("abc" -> "abc"))
- res20: Boolean = true
Java代码
- scala> def isStringArray(x: Any) = x match {
- case a: Array[String] => "yes"
- case _ => "no"
- }
- isStringArray: (x: Any)java.lang.String
- scala> val as = Array("abc")
- as: Array[java.lang.String] = Array(abc)
- scala> isStringArray(as)
- res21: java.lang.String = yes
- scala> val ai = Array(1, 2, 3)
- ai: Array[Int] = Array(1, 2, 3)
- scala> isStringArray(ai)
- res22: java.lang.String = no
f.绑定变量
1. 变量名e+ 符号@+pattern 的形式,
pattern 完成普通的模式匹配,如果匹配成功,则将 被匹配的对象赋值给指定的变量
例如:
Java代码
- expr match {
- case UnOp("abs", e @ UnOp("abs", _)) => e
- case _ =>
- }
11.4 模式中的条件表达式
a: 在模式中 一个变量只允许出现一次
b:可以在模式中添加if 条件表达式 进行判断
例如:
Java代码
- def simplifyAdd(e: Expr) = e match {
- case BinOp("+", x, y) if x == y =>
- BinOp("*", x, Number(2))
- case _ => e
- }
Java代码
- // match only positive integers
- case n: Int if 0 < n => ...
- // match only strings starting with the letter ‘a’
- case s: String if s(0) == 'a' => .
11.5 pattern overlap 模式交叠
a:pattern 是根据他们写的顺序 进行匹配的。例如:
Java代码
- def simplifyAll(expr: Expr): Expr = expr match {
- case UnOp("-", UnOp("-", e)) =>
- simplifyAll(e)
- // ‘-’ is its own inverse
- case BinOp("+", e, Number(0)) =>
- simplifyAll(e)
- // ‘0’ is a neutral element for ‘+’
- case BinOp("*", e, Number(1)) =>
- simplifyAll(e)
- // ‘1’ is a neutral element for ‘*’
- case UnOp(op, e) =>
- UnOp(op, simplifyAll(e))
- case BinOp(op, l, r) =>
- BinOp(op, simplifyAll(l), simplifyAll(r))
- case _ => expr
- }
b:如果编译器检查到 之前的模式已经将所有的模式覆盖了,那么在这个模式之后定义的模式会被标注为unreachable code
11.6 sealed classes
a:为了得到编译器的帮助。列出所欲的模式组合,需要将case class 的父类定义为 sealed
b:加了sealed 关键字的class 除了那些在同一个文件中的子类外不允许添加任何子类
c:如果打算写一些用于模式匹配的类,应该考虑用sealed 封装 这些类的父类
例如:
Java代码
- sealed abstract class Expr
- case class Var(name: String) extends Expr
- case class Number(num: Double) extends Expr
- case class UnOp(operator: String, arg: Expr) extends Expr
- case class BinOp(operator: String,
- left: Expr, right: Expr) extends Expr
d:使用unchecked annotation 来避免编译器检查各种模式的组合,避免编译器发出这种警告,“ 表达式:@unchecked”例如
Java代码
- def describe(e: Expr): String = (e: @unchecked) match {
- case Number(_) => "a number"
- case Var(_)
- => "a variable"
- }
11.7 Option 类型
a:scala 为Option value 提供Option 类型,如果真实的值存在 则返回真实的值,否则返回None object
例如:
Java代码
- cala> val capitals =
- Map("France" -> "Paris", "Japan" -> "Tokyo")
- capitals: scala.collection.immutable.Map[java.lang.String,
- java.lang.String] = Map(France -> Paris, Japan -> Tokyo)
- scala> capitals get "France"
- res23: Option[java.lang.String] = Some(Paris)
- scala> capitals get "North Pole"
- res24: Option[java.lang.String] = None
- scala> def show(x: Option[String]) = x match {
- case Some(s) => s
- case None => "?"
- }
- show: (x: Option[String])String
- scala> show(capitals get "Japan")
- res25: String = Tokyo
- scala> show(capitals get "France")
- res26: String = Paris
- scala> show(capitals get "North Pole")
- res27: String = ?
11.8 pattern every
1. 在变量定义中的模式 ,例如 在一个赋值中生成多个变量
Java代码
- scala> val myTuple = (123, "abc")
- myTuple: (Int, java.lang.String) = (123,abc)
- scala> val (number, string) = myTuple
- number: Int = 123
- string: java.lang.String = abc
2.在function 中的case squence, 为构造一个函数提供多个入口,见 Function1
例如:
Java代码
- val withDefault: Option[Int] => Int = {
- case Some(x) => x
- case None => 0
- }
- scala> withDefault(Some(10))
- res28: Int = 10
- scala> withDefault(None)
- res29: Int = 0
上述定义其实是 生成一个Function1 类
3.对于下面这种额外的情况: 在使用函数之前要先判断 输入的参数是否满足条件,如果满足,则该函数能够返回正确的值,否则则会抛出异常。对于这样的函数 外面可以定义为 :Parial Function
例如:
Java代码
- new PartialFunction[List[Int], Int] {
- def apply(xs: List[Int]) = xs match {
- case x :: y :: _ => y
- }
- def isDefinedAt(xs: List[Int]) = xs match {
- case x :: y :: _ => true
- case _ => false
- }
4.例如:
Java代码
- val second: List[Int] => Int = {
- case x :: y :: _ => y
- }
second 函数对于list 中的元素<2 时,则会抛出异常。为了避免这种情况,可以将second 定义为Parital Function .
Java代码
- val second: PartialFunction[List[Int],Int] = {
- case x :: y :: _ => y
- }
那么在使用这个函数前就可以先用second.isDefinedAt 这个方法先判断是否满足条件,如果满足,之后在调用该函数
5. 表达式中的模式
例如 :
Java代码
- scala> for ((country, city) <- capitals)
- println("The capital of "+ country +" is "+ city)
- The capital of France is Paris
- The capital of Japan is Tokyo
- scala> val results = List(Some("apple"), None,
- Some("orange"))
- results: List[Option[java.lang.String]] = List(Some(apple),
- None, Some(orange))
- scala> for (Some(fruit) <- results) println(fruit)
- apple
- orang
将集合内的元素展开,如果符合指定的模式,则输出,否则 不输出