5.1更好的switch
与default等效的是捕获所有的case_模式。如果没有模式匹配，抛出MatchError，每个case中，不用break 语句。
在match中使用任何类型，而不仅仅是数字。
5.2守卫
1，match也提供守卫功能，守卫可以是Boolean
5.3模式中的变量
如果case关键字后面跟着一个变量名，那么匹配的表达式会被赋值给那个变量。
5.4类型模式
你可以对表达式的类型进行匹配，在匹配类型的时候，必须要设置一个变量名。
匹配操作发生在运行期，所以不能比对一个泛型类型，但是可以使用通配符。
5.5匹配数组、列表和元组
Array（0）匹配只有一个元素且为0的数组。
Array（x，y）匹配数组有两个元素，并将两个元素赋值为x和y。
Array（0，_*）匹配数组以0开始。
集合元素通过匹配绑定到变量，这样的操作叫做“析构”。
5.6提取器
模式如何匹配数组、列表和元组的，这个背后的机制叫做提取器，一个对象如果带有从对象中提取值的unapply和unapplySeq方法，apply方法接受构造参数，生成对象；而unapply方法接受对象，提取值，是一个反向操作。到底什么时候用unapply什么时候用unapplySeq，要看参数个数。
5.7变量声明中的模式
在变量声明中使用模式
5.8For表达式中的模式.
在for表达式中使用提取器
5.9样例类
样例类首先是类，除此之外它是为模式匹配而优化的类，样例类用case关键字进行声明
5.10Copy方法和带名参数
方法和带名参数copy创建一个与现有对象值相同的新对象，并可以通过带名参数来修改某些属性。
5.11Case语句的中置表达式
如果unapply方法产出一个元组，你可以在case语句中使用中置表示法。
5.12匹配嵌套结构
样例类经常被用于嵌套结构。
5.13密封类.
如果想让case类的所有子类都必须在申明该类的相同的文件中定义，可以将样例类的通用超类声明为sealed，叫做密封类，密封就是外部用户不能在其他文件中定义子类。
5.14模拟枚举
样例类可以模拟出枚举类型
5.15偏函数
偏函数之所以“偏”，原因在于它们并不处理所有可能的输入，而只处理那些能与至少一个case语句匹配的输入。
在偏函数中只能使用case 语句，而整个函数必须用花括号包围。
import org.scalatest.FunSuite
class Chapter04Test extends FunSuite {
test("core01") {
//模式匹配
var sign = 0
for (ch <- "+-!") {
ch match {
case '+' => sign = 1
case '-' => sign = -1
case _ => sign = 0
}
println(sign)
}
}
test("core02") {
//匹配模式添加条件判断 守卫模式
for (ch <- "+-!3") {
var sign = 0
var digit = 0
ch match {
case '+' => sign = 1
case '-' => sign = 11
//条件判断
case _ if Character.isDigit(ch) => digit = Character.digit(ch, 10)
case _ => sign = 13
}
println(ch + " " + sign + " " + digit)
}
}
test("core03") {
//变量匹配
var str = "+!-3"
for (i <- str.indices) {
var sign = 0
str(i) match {
case '+' => sign = 1
case '-' => sign = 11
case _ => sign = 12
}
println(str(i) + "\t" + sign)
}
import scala.math._
val x = math.random
x match {
case Pi => "it is PI"
case _ => "it is not PI"
}
}
test("core04") {
//匹配类型
for (obj <- Array(42, "42", BigInt(42), BigInt, 42.0)) {
val result = obj match {
case x: Int => x
case s: String => s.toInt
case _: BigInt => Int.MaxValue
case BigInt => 11
case _ => 0
}
println(result)
}
}
test("core05") {
//匹配数组
for (arr <- Array(Array(0), Array(1, 0), Array(0, 0, 1))) {
val result = arr match {
case Array(0) => "0"
case Array(x, y) => x + "_" + y
case Array(0, _*) => "0....."
case _ => "something"
}
println(result)
}
//匹配列表
for (lst <- Array(List(0), List(1, 0), List(0, 0, 0))) {
val result = lst match {
case 0 :: Nil => "0"
case x :: y :: Nil => x + " " + y
case 0 :: tail => "0>>>>"
case _ => "something"
}
println(result)
}
//匹配元祖
for (pair <- Array((0, 1), (1, 0), (0, 0))) {
val result = pair match {
case (0, _) => "0>>>"
case (y, 0) => y + "0"
case _ => "neither is 0"
}
println(result)
}
}
test("core06") {
// apply方法接受构造参数，生成对象；
// unapply方法接受对象，提取值，是一个反向操作。
val arr = Array(0, 1)
arr match {
case Array(0, x) => x
}
//提取序列
Array.unapplySeq(arr)
}
test("core07") {
//在变量声明中使用模式
val (x, y) = (1, 2)
val Array(first, second, _*) = Array(1, 2, 3, 4)
}
test("core08") {
//for循环匹配
import scala.collection.JavaConverters._
for ((k, v) <- System.getProperties.asScala) {
print(k + "_" + v)
}
//守卫模式
for ((k, v) <- System.getProperties.asScala if v == "") {
print(k + "_" + v)
}
}
test("core09") {
//样例类匹配
for (amt <- Array(Dollar(10.0), Curreny(1000, "EU"))) {
val result = amt match {
case Dollar(v) => "$" + v
case Curreny(_, u) => u
case _ => ""
}
print(result)
}
}
test("core10") {
// 方法和带名参数copy创建一个与现有对象值相同的新对象，并可以通过带名参数来修改某些属性。
val amt = Curreny(29.95, "EU")
val price = amt.copy(value = 19.95)
print(price)
}
test("core11") {
//匹配中置表达式
val amt = Curreny(1000.0, "EU")
//中置表达式
amt match {
case a Curreny u => a + " " + u
}
val list = List(1, 2, 3)
list match {
case h :: t => h + t.length
case _ => 0
}
}
test("core12") {
// 样例类经常被用于嵌套结构。
}
test("core13") {
// 如果想让case类的所有子类都必须在申明该类的相同的文件中定义，可以将样例类的通用超类声明为sealed，叫做密封类，
// 密封就是外部用户不能在其他文件中定义子类。
}
test("core14") {
// 样例类可以模拟出枚举类型
for (color <- Array(Red, Yellow, Green)) {
println(
color match {
case Red => "stop"
case Yellow => "hurry up"
case Green => "go"
}
)
}
}
test("core15") {
// 偏函数之所以“偏”，原因在于它们并不处理所有可能的输入，而只处理那些能与至少一个case语句匹配的输入。
// 在偏函数中只能使用case 语句，而整个函数必须用花括号包围。
val f: PartialFunction[Char, Int] = {
case '+' => 1
case '-' => 11
}
f('-')
}
}
case class Dollar(value: Double)
case class Curreny(value: Double, unit: String)
//密封类
sealed abstract class TrafficLightColor
case object Red extends TrafficLightColor
case object Yellow extends TrafficLightColor
case object Green extends TrafficLightColor
网友评论