模式匹配—基础使用

一、match case的基本格式

执行流程是：如果value匹配到了pattern1，就执行结果1，如果都没有匹配到，就执行 _ 对应的内容。

def main(args: Array[String]): Unit = {
  // 输入1，输出单词one
  // 输入2，输出单词two
  // 输出3，输出单词three
  // 输入其他，输出单词other

  // 1.如果能精准匹配成功，就会执行后面的代码
  // 2.case_ 它表示可以匹配任意的内容。一定要放在match case 的最后一条
  // 3.case_ 不能省略：如果匹配不成功，就会报错

  // 1.从键盘获取数字
  val code=10
  //2.从matchase进行匹配
  code match {
    case 1=>println("one")
    case 2=>println("two")
    case _=>println("未知")
  }
}

二、匹配的变量类型

（1）.匹配精确值和数据类型

/*
* 匹配变量类型
* 1.匹配精确值
* 2.匹配数据类型
*
* */
object matchase02 {
  def processValue(value:Any):Unit={
    value match {
      case x: Int=>println("Int")
      case x:String=>println("String")
      case _=>println("other")
    }
  }

  def main(args: Array[String]): Unit = {
    val obj=10
    processValue(obj)
  }

（2）.匹配元素个数

* 3.匹配元素的个数
*
* */
object matchase03 {
  def processValue(value:Any):Unit={
  }

  def processNum(value:Any):Unit={
    value match {
      case (a,b,c) => println(s"三个元素的元组，第一个元素是${a}")
      case (x,y)=> println("两个元素的元组")
      case _ => println("其他")
    }
  }

  def main(args: Array[String]): Unit = {
//    val obj=10
//    processValue(obj)
    processNum((1,2))
    processNum((1,2,3))
  }

三、高阶匹配之元组元素数量以及元素特征

前面的匹配都是精准匹配：变量和值是相等的。但是呢，scala中的模式匹配的规则是非常强大的，不一定是精准的匹配值，还可以根据元组的元素的个数来匹配。

模式匹配还可以根据数组元素的个数，元素的特征来匹配。

* 4.匹配数组元素个数，元素特征
*
* */
object matchase04 {

  def matchArray(arr:Any):Unit= {
    arr match {
      case Array(x, y) => println("匹配到有两个元素的数组", x, y)
      case Array(1, b, c) => println("匹配到有三个元素的数组，第一个元素是1")
      case Array(a, b, c) => println("匹配到有三个元素的数组", a, b, c)
      case Array(10, _*) => println("第一个元素是10，元素的个数有任意个")
      case _ => println("没有匹配到")
    }
  }

  def main(args: Array[String]): Unit = {
    val arr1=Array(1,2,3)
    val arr2=Array(2,2,3)
    val arr3=Array(10,2,3,1)
    matchArray(arr1)
    matchArray(arr2)
    matchArray(arr3)
  }

四、高阶匹配之匹配案例类

模式匹配还根据案例类的不同，匹配不同的案例类和其中的字段信息。

格式：

对象 match {

case 样例类类型1（字段1，字段2）=> 表达式

case 样例类类型2（字段1，字段2，字段3）=> 表达式

case _ => 其他

}

注意： 样例类1中的字段个数要与之对应。

5.匹配案例类
*
* */
object matchase05 {
  case class Circle(r: Double)
  case class Rectangle(w: Double, h: Double)

  def calculateArea(shape:Any):Double={
    shape match {
      case Circle(r)=> 3.14*r*r
      case Rectangle(w,h)=>w*h
      case _ => 0.0
    }
  }

  def main(args: Array[String]): Unit = {
    val circle=Circle(2.0)
    val rectangle=Rectangle(2.0,3.0)
    println(calculateArea(circle))
    println(calculateArea(rectangle))
  }

五、高阶匹配之变量声明时的匹配

* 6.变量声明时的匹配
*
* */
object matchase06 {
  def main(args: Array[String]): Unit = {
    val arr=Array(11,22,33,4,5)
    val Array(x,y,z, _*)=arr
    println(x,y,z)
  }