scala 开发入门（8）-- 模式匹配

模式匹配是scala提供的最重要的语言特性，在实际开发过程中应用非常广泛，可以说模式匹配在scala语言中无处不在。package cn.scala.chaper8
/**
*使用scala中的模式匹配可以避免 Java 语言中 switch 语句会意外陷入分支的情况
*/
object ScalaExample extends App{
for (i <- 1 to 5)
i match{
case 1 => println(1)
case 2 => println(2)
case 3 => println(3)
case _ => println("其他")
}
}

//还可以加入表达式，变量模式
i match{
case x if (x%2 == 0) =>println(s"$x 能够被 2 整除")
//其他不操作
case _ =>
}

前面的两段代码分别简单的介绍了模式匹配中的 常量模式 和 变量模式，接下来查看构造函数模式

/**
* 构造函数模式匹配
*/
object ScalaExample extends App{
//定义一个样例类
case class Dog(val name:String,val age:Int)
//利用构造函数创建对象
val dog = Dog("Pet",2)

def patternMatching(x:AnyRef) = x match{
case Dog(name,age) => println(s"Dog name = $name,age = $age")
case _ =>
}
patternMatching(dog)
}

//注意前面构造函数匹配用的是样例类 case class，如果普通类则需要在伴生对象中定义 unapply 方法
object ScalaExample extends App{
//定义普通类 Dog
class Dog(val name:String,val age:Int)
//Dog类的伴生对象
object Dog{
//手动实现 unapply 方法
def unapply(dog:Dog):Option[(String,Int)] = {
if(dog != null) Some(dog.name,dog.age) else None}
}
//利用构造函数创建对象，因为 Dog 是普通的类且伴生对象没有定义 apply，所以必须用显式的 new 来创建对象
val dog = new Dog("Pet",2)
def patternMatching(x:AnyRef) = x match{
//因为在 Dog 的伴生对象中实现了 unapply 方法，此处可以使用构造函数模式
case Dog(name,age) => println(s"Dog = $name,age = $age")
case _ =>
}
patternMatching(dog)
}

序列模式

/**
* 序列模式
*/
object ScalaExample extends App{
val arrInt = Array(1,2,3,4)
def patternMatching(x:AnyRef) = x match{
//序列模式，与构建序列的作用相反，用于对序列中的元素内容进行析取
case Array(first,second) => paintln(s"序列中第一个元素=$first,第二个元素=$second")
//first,second 分别匹配序列中的第一、二个元素，_* 匹配序列中剩余其他元素
case Array(first,_,three,_*) => println(s"序列中第一个元素=$first，第三个元素=$three")
case _ =>
}
patternMatching(arrInt)
}

结果如下：
序列中第一个元素=1，第三个元素=3

元组模式

/**
* 元组模式
*/
object ScalaExample extends App{
//定义一个元组
val tupleInt = (1,2,3,4)
def patternMatching(x:AnyRef) = x match{
//元组模式，匹配两个元素的元组
case (first,second) => println(s"元组中第一个元素=$first,第二个元素=$second")

//first,three 分别匹配元组中第一、三个元素
case(first,_,three,_) => println(s"元组中第一个元素=$first,第三个元素=$three")
//元组模式中不能用 _* 的匹配模式
//case(first,_,three,_*) =>  错误
case _ =>
}
patternMatching(tupleInt)
}

结果如下：
元组中第一个元素=1，第三个元素=3

类型模式

/**
* 类型模式
*/
object ScalaExample extends App{
//定义对象
class A
class B extends A
class C extends A
val b = new B
val c = new C
def patternMatching(x:AnyRef) = x match{
//类型模式，匹配字符串
case x:String => println("字符串类型")
//类型模式，匹配类B
case x:B => println("对象类型为B")
//类型模式，匹配类A
case x:A => println("对象类型为A")
case _ => println("其他类型")
}
patternMatching("Scala Pattern Matching")
patternMatching(b)
patternMatching(c)
}

代码运行结果：
字符串类型
对象类型为B
对象类型为A

变量绑定模式

/**
* 变量绑定模式
*/
object ScalaExample extends App{
//定义对象
case class Dog(val name:String,val age:Int)
val dog = Dog("Pet",2)

def patternMatching(x:AnyRef) = x match{
//变量绑定模式，匹配成功，则将整个对象赋值为变量 d
case d@Dog(_,_) => println("变量绑定模式返回的变量值为："+d)
case _ =>
}
patternMatching(dog)
}

代码运行结果如下：
变量绑定模式返回的变量为：Dog(Pet,2)

/**
*变量绑定模式
*/
object ScalaExample extends App{
//定义一个对象
val list = List(List(1,2,3,4),List(4,5,6,7,8,9))
def patternMatching(x:AnyRef) = x match{
//变量绑定模式
case el@List(_,e2@List(4,_*)) => println("变量e1 = "+e1+"\n,变量e2 = "+e2)
case _ =>
}
patternMatching(list)
}

代码运行结果:
变量e1 = List(List(1,2,3,4),List(4,5,6,7,8,9))
变量e2 = List(4,5,6,7,8,9)

备注：
在 for 循环中的模式匹配原则基本同上，只是可能是以上多种的混搭。常见的有 常量模式匹配 和 元组模式匹配 的混搭。