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 循环中的模式匹配原则基本同上，只是可能是以上多种的混搭。常见的有 常量模式匹配 和 元组模式匹配 的混搭。