Scala基础———匹配模式

Match

   /*
    * 匹配模式————match
    * 不需要使用break
    * 使用case_进行通配
    * Scala中match...case取代Java中的switch...case
    * */
    *  var result = 0
      val op = '-'

      op match {
        case '+' => result=1
        case '*' => result = -1
        case _ => result=0
      }
      println(result)

守卫

    /*
    * 匹配模式————守卫
    * 必须加上通配，case_， 不然就会报错
    * */
    * for(c<- "+-*/123"){
        c match {
          case _  if  Character.isDigit(c) => println("++:"+c)
          case '+' => println("+++++++++")
          case '-' => println("---------")
          case '*' => println("*********")
          case '/' => println("/////////")
          case _ => println("OKOKOK")
        }
      }

类型匹配

   /*
    * 类型匹配
    * 匹配任意对象的类型
    * Map类型的泛型在匹配的时候，会自动删除泛型类型，
    * 只会匹配到Map类型，而不会精确到Map里面的泛型类型。
    * Array数组泛型不会被擦除，会精确匹配
    * */
      val a = 8
      val obj = if(a == 1) 1
      else if(a == 2) "2"
      else if(a == 3) BigInt(3)
      else if(a == 4) Map("aa" -> 1)
      else if(a == 5) Map(1 -> "aa")
      else if(a == 6) Array(1, 2, 3)
      else if(a == 7) Array("aa", 1)
      else if(a == 8) Array("aa")
      val r1= obj match {
        //case后加变量，若匹配到Int，则把obj的值赋值给x，返回x
        case x:Int=>x
        case s:String=>s
        case bi:Int=>bi
        case m1:Map[String,Int]=>m1
        case m2:Map[Int,String]=>m2
        case a1:Array[Int]=>a1
        case a3:Array[String]=>a3
        case a2:Array[Any]=>a2
        case _=>println()

      }
      println(r1+":"+r1.getClass.getName)

数组匹配

for(arr <- Array(Array(0), Array(1, 0), Array(1, 1, 0), Array(0, 1, 0), Array(1, 1, 0, 1))){
        arr match {
          case Array(0) => println("array(0)")
          case Array(x,y) => println("array(x,y)"+x+","+y)
          case Array(x,y,z) => println("array(x,y,z)"+x+","+y+","+z)
          //case Array(1,_*) => println("Array(1,_*)")
            //匹配第一个数字为1的array数组，@符号代表将后续所有元素都赋值给arr，映射
          case Array(1,arr @ _*) => println("Array(1,_*)"+arr.length)
          case _ =>println("通配")

匹配模式中的提取机制

  object Square {
  /*
  * unapply
  * 调用unapply，传入number
  * 接收返回值并判断返回值是None，还是Some
  * 如果是None，则不匹配，直接进行下一个case
  * 如果是Some，则将其解开，并将其中的值赋值给n（就是case Square(n)中的n）
  * */
  //将math.sqrt(z)的值包装到Some中
  def unapply(z: Double): Option[Double] = Some(math.sqrt(z))
}

/*
    * 匹配模式中的提取机制
    * case中unapply方法返回some集合则为匹配成功，返回none集合则为匹配失败
    * */
     val n= 36.0
      n match {
        //输出36.0+6.0
        //s为标记 $为提取
        //case后的变量值，如果匹配成功，将匹配的值赋值给变量名
        case Square(result) => println(s"${n}+${result}")
        case _ => println("**")
      }

for循环中的匹配模式

     import scala.collection.JavaConverters._
      for((k,v)<- System.getProperties.asScala){
        println(k+"--------"+v)
      }
      //匹配没有值的键值对
      for((k,"")<- System.getProperties.asScala){
        println(k+"--------")
      }
      for((k,v)<- System.getProperties.asScala if v=="" || v==null){
        println(k+"--------")
      }