14_Scala_模式匹配上_匹配_守卫_变量_类型匹配_数组/列表/元祖

1 Scala中的模式匹配
 match关键字声明，每个分支采用case关键字进行声明，
从第一个case分支开始，成功 => 那么执行对应的逻辑代码， 不成功，继续执行下一个分支进行判断
所有case都不匹配，那么会执行case _ 分支
如都不匹配 且 没有写case _ 分支，会抛出MatchError

2 守卫模式：匹配某个范围的数据，在模式匹配中增加条件守卫

3 变量： case关键字后跟变量名，那么match前表达式的值会赋给该变量

4 类型匹配：匹配对象的任意类型，这样做避免了使用isInstanceOf和asInstanceOf方法

object Mathinit {
  def main(args: Array[String]): Unit = {
    //1. match (类似java switch) 和  case 是关键字
    //2. 如果匹配成功， 则 执行 => 后面的代码块.匹配的顺序是从上到下，匹配到一个就执行对应的 代码
    //4. => 后面的代码块 不要写 break ,会自动的退出match
    //5. 如果一个都没有匹配到，则执行 case _ 后面的代码块
    val oper = "alex"
    for (item <- oper) {
      val result_init = item match {
        case 'a' => "this is a"
        case 'x' => "this is x"
        case _ => "啥也不是，完蛋" // 默认值
      }
            println(result_init)
    }

    // 2 match 守卫模式 如果想要表达匹配某个范围的数据，就需要在模式匹配中增加条件守卫
    //3  变量： case关键字后跟变量名，那么match前表达式的值会赋给该变量
    //如果 case 后有 条件守卫即if ,那么这时的 _ 不是表示默认匹配  表示忽略 传入 的 i
    for (i <- 1 until 5) {
      val result_defand = i match {
        case ax if i > 2 => print(ax + "\t"); "大于2" // 把i的值传给 ax,   输出3	大于2
        case _ if i == 1 => "是1" // _表示忽略 传入 的 i
        case _ => "啥也不是"
      }
      println(result_defand)
    }

    // 4 类型匹配：匹配对象的任意类型，这样做避免了使用isInstanceOf和asInstanceOf方法
    for (item <- 1 to 5){
    val a = scala.util.Random.between(1,5)
      val obj = if (a == 1) 1
      else if (a == 2) "2"
      else if (a == 3) BigInt(3)
      else if (a == 4) Map("aa" -> 1)

      // 表示 将obj 赋值给 aa   aa = obj 然后 aa : 匹配后面类型
      val result = obj match {
        case aa: Int => "this is Int" + " "+ aa
        case bb: String => "this is String " + " "+  bb
        case cc: BigInt => "this is BigInt " +cc + " "+ Int.MaxValue
        case dd: Map[String, int] => "this is Map " + " "+ dd
        case _ => "啥也不是，完蛋"
      }
      println(result)
    }
  }}

5 匹配数组/列表/元祖

object MatchArr_List_TupleTest {
  def main(args: Array[String]): Unit = {

    // Match Array
    //       this this array(0)   (0,1)      begin with 0    啥也不是，完蛋
    val arr1 = Array(Array(0), Array(1, 0), Array(0, 1, 2), Array(1, 1, 0, 1))
    for (item <- arr1) {
      val result = item match {
        case Array(0) => "this this array(0)"  //Array(0) 匹配只有一个元素且为0的数组
        case Array(x, y) => (y, x) //Array(x,y) 匹配数组有两个元素，并将两个元素赋值为x和y
        case Array(0, _*) => "begin with 0"   //Array(0,_*) 匹配数组以0开始

        case _ => "啥也不是，完蛋"
      }
//      println(result)
    }
    // Match List

    var arr_List =Array(List(0), List(1, 0), List(99), List(5, 0, 0), List(1, 0, 0))
    for (item <- arr_List) {
      val result_List = item match {
        case 0 :: Nil => "Nil => List(0)"  // 匹配List(0)
        case a :: b :: Nil => (b, a)   //匹配list(a,b)
        case a :: Nil => a       //  匹配 list(a)
        case 5 :: othersss => (othersss, 5)  // List(5, 0, 0) => (List(0, 0),5)
        case _ => "啥也不是，完蛋"
      }
//      println(result_List)
    }

    // Match Tuple
    val arr3 = Array((0, 1),  (10, 30),  (1, 0, 2))
    for (item <- arr3){
      val result_tuple = item match {
        case (0, _) => "begin with 0" // 0 开头的二元组， _表忽略
        case (x, y) => (y, x) //匹配二元组
        case (x, 0, z) => (z, 0, x) //  匹配三元组，第二个必须是 0
      }
      println(result_tuple)
    }}}

6  变量声明中的模式  match中每一个case都可以单独提取出来  => 快速定义 一次定义多个变量
变量声明中的模式
for表达式中的模式

object MatchToForTest {
  def main(args: Array[String]): Unit = {

    // 变量声明中的模式
    val (x, y, z) = (1, 2, "hello")
//    println("x=" + x)
    val (q, r) = BigInt(10) /% 3 //说明  q = BigInt(10) / 3 r = BigInt(10) % 3

    val arr = Array(1, 7, 2, 9)
    val Array(first, second, third, _*) = arr // 提出arr的前两个元素, arr 是Array类型，赋值也需要个Array来接受
//    println(first + " " +first.getClass)  // 1 int
//    println(first, third) // (1,2)
//    println(3,4) // (3,4)

    //说明 : 只遍历出 value =40 的key-value ,其它的过滤掉
    val map1 = Map("Alex" -> 35, "BoB" -> 40, "Robbin" -> 28)
    for ((k, 40) <- map1){
      println(k + " " + map1.get(k).get )
    }
    //说明 : 只遍历出 value < 30 的key-value ,这样写更加灵活
    for((k,v) <- map1 if v <30 ){
      println(k + " " + map1.get(k).get )
    }

  }}