scala模式匹配-基础使用

match case的基本格式

package matchcase
/*
* 任务
* 1. 编写一个函数，传入一个元祖，其中元素个数并不相同
*
* match case 的用法
* （1）类似于 if else if 这种多分支结构，精确匹配值
*1.case_ 是不可省略的 ，如果匹配不成功 ，又没有case _ ，程序会报错
* 2 case _ 必须要放在最后
* （2）类似于 switch case，精确匹配类型
 */
*

object matchcase01 {
  def main(args: Array[String]): Unit = {
    println(getProvinceName(11))
    println(getProvinceName(12))
    println(getProvinceName(13))
  }
  def getProvinceName(code:Int):String= {
    code match {
      case 11 => "北京"
      case 12 => "天津"
      case 13 => "河北"
      case _ => "未知"
    }
  }
}

package matchcase

/*
* 任务
* 1. 编写一个函数，传入一个元祖，其中元素个数并不相同
*
* match case 的用法
* （1）类似于 if else if 这种多分支结构，精确匹配值
*1.case_ 是不可省略的 ，如果匹配不成功 ，又没有case _ ，程序会报错
* 2 case _ 必须要放在最后
* （2）匹配元组元素的数量
 */
*

object matchcase02 {
  def main(args: Array[String]): Unit = {
    val xiaohong = (100, 100, 100)
    val xiaoming = (89, 98)

    getScore(xiaohong)
    getScore(xiaoming)
    getScore((1, 2, 3, 4))
  }

  def getScore(score: (Int, Int, Int)): Unit = {
    score match {
      case (a, b, c) => println("元组中有三个元素：a = " + a + "b = " + b + ",c = " + c)
      case (a, b) => println("元组中有两个元素：a = " + a + "b = " + b)
      case _ => println("未知")
    }
  }
}

（三）高阶匹配之元组元素数量

package matchcase

/*
* 任务
* 1. 编写一个函数，传入一个元祖，其中元素个数并不相同
*
* match case 的用法
* （1）类似于 if else if 这种多分支结构，精确匹配值
*1.case_ 是不可省略的 ，如果匹配不成功 ，又没有case _ ，程序会报错
* 2 case _ 必须要放在最后
* （2）匹配元组元素的数量
* （3）匹配变量类型
 */
*

object matchcase03 {
  def main(args: Array[String]): Unit = {
  testType(1)
  testType(1.1)
  testType("1")

  }
  def testType(i:Any):Unit= {
    i match {
      case x: Int => println("当前变量是：Int")
      case x: Double => println("当前变量是:Double")
      case _ => println("未知")
    }
  }
}

（ 四）高阶匹配之匹配元素特征

package matchcase

/*
* 任务
* 1. 编写一个函数，传入一个元祖，其中元素个数并不相同
*
* match case 的用法
* （1）类似于 if else if 这种多分支结构，精确匹配值
*1.case_ 是不可省略的 ，如果匹配不成功 ，又没有case _ ，程序会报错
* 2 case _ 必须要放在最后
* （2）匹配元组元素的数量
* （3）匹配变量类型
* （4）匹配元素特征
 */
*

object matchcase04 {
  def main(args: Array[String]): Unit = {
    testType(Array(1,2,3))
    testType(Array(1,2,3,4))
    testType(Array(11,2,3,4))
    testType(Array(11,1,3,4))
  }
  def testType(i:Any):Unit= {
    arr match {
      case Array(1,x,y) => println("arr是一个数组，有三个元素，第一个1")
      case Array(1,x,y,z) => println("arr是一个数组，有四个元素，第一个1")
      case Array(x,1,y,z) => println("arr是一个数组，有四个元素，第二个11")
      case _ => println("未知")
    }
  }
}

（五）高阶匹配之变量类型匹配

package matchcase

/*
* 任务
* 1. 编写一个函数，传入一个元祖，其中元素个数并不相同
*
* match case 的用法
* （1）类似于 if else if 这种多分支结构，精确匹配值
*1.case_ 是不可省略的 ，如果匹配不成功 ，又没有case _ ，程序会报错
* 2 case _ 必须要放在最后
* （2）匹配元组元素的数量
* （3）匹配变量类型
* （4）匹配元素特征
* （5）样例类及其属性
 */


object matchcase05 {
  //定义一个样例类：圆形。它有一个属性：半径
  case class Circle(radius: Double)

  //定义一个样例类：矩形。它有两个属性：长和宽
  case class Rectangle(width: Double, height: Double)
  //定义一个方法：用来求圆形，矩形的面积

  def getArea(obj: Any): Unit = {
    obj match {
      case Circle(radius) => println("圆的面积是：" + radius * radius * 3.14)
      case Rectangle(width, height) => println("矩形的面积是：" + width * height)
      case _ => println("未知")
    }
  }

  def main(args: Array[String]): Unit = {
    getArea(Circle(2))
    getArea(Rectangle(2, 3))
    getArea("abc")
  }
}

package matchcase

/*
* 任务
* 1. 编写一个函数，传入一个元祖，其中元素个数并不相同
*
* match case 的用法
* （1）类似于 if else if 这种多分支结构，精确匹配值
*1.case_ 是不可省略的 ，如果匹配不成功 ，又没有case _ ，程序会报错
* 2 case _ 必须要放在最后
* （2）匹配元组元素的数量
* （3）匹配变量类型
* （4）匹配元素特征
* （5）样例类及其属性
* （6）变量声明中的模式匹配
 */


object matchcase06 {

  def main(args: Array[String]): Unit = {
    val arr =Array(1,2,3,4)
    
    //定义三个变量，分别设置初始值为arr的前三个元素的值
    var a = arr(0)
    var b = arr(1)
    var c = arr(2)
    println("a = " + a + "b = " + b + "c = " + c)
      //使用模式匹配，将arr的前三个元素分别赋值给a,b,c
    val Array(x,y,z,_*) = arr
    //_* 占位符，表示多的部分放在这
    println("x = " + x + "y = " + y + "z = " + z)
  }
}

package matchcase

/*
* 任务
* 1. 编写一个函数，传入一个元祖，其中元素个数并不相同
*
* match case 的用法
* （1）类似于 if else if 这种多分支结构，精确匹配值
*1.case_ 是不可省略的 ，如果匹配不成功 ，又没有case _ ，程序会报错
* 2 case _ 必须要放在最后
* （2）匹配元组元素的数量
* （3）匹配变量类型
* （4）匹配元素特征
* （5）样例类及其属性
* （6）变量声明中的模式匹配
 */


object matchcase07 {

  def main(args: Array[String]): Unit = {
    val a = 11

    a match {
      case x:Int if a > 10 => println("a 是大于10的Int")
      case _ => println("a is not Int")
    }
  }
}