【Scala入门学习】匹配模式match

1. match匹配

match 语句用在当需要从多个分支中进行选择的场景，类似于java 中的switch 语句。

语法：

Scala 复制代码

变量 match{
    case "值"  => 语句块1  // 语句块后不用加break
    case "值2" => 语句块2
    case _ => 语句块N    // 类似于java的default
}

其中：

1）case 后面的表达式可以是任何类型的常量，如字段串、类、元组、集合等；

2）与java的switch不同的是，match 结构中不需要break 语句来跳出判断；

3）最后一个case语句用了通配符"_"，相当于java的default；

4）如果匹配不到，就会报错；

2. 字符串匹配

Scala 复制代码

def main(args: Array[String]): Unit = {
//    while(true){
//      val number = StdIn.readInt()
//      if (number == 1)
//        println("start")
//      else if (number == 2)
//        println("running")
//      else if (number == 3)
//        println("stop")
//    }
    while(true){
      val number = StdIn.readInt()
      number match {
        case 1 => println("start")
        case 2 => println("running")
        case 3 => println("stop")
        case _ => println("invalid number")
      }
    }

返回值和守卫

Scala 复制代码

    //    val age = 20
    //    val res = age match {
    //      case 18 => 10
    //      case 20 => 200
    //    }
    //    println(res)
    val name = "zhangsan"
    val age = 20

    val res: AnyVal = name match {
      case "zhangsan" if (age > 18) => 10000
      case "lisi" => 8000
      case "wangwu" => 8000
      case _ => println("think think ..")
    }
    println(res)

    //    name match {
    //      case "zhangsan" if(age>18) => println("u r in!!!")
    //      case "lisi" => println("not in")
    //      case "wangwu" =>println("not in")
    //      case _ => println("think think ..")
    //    }

3. 类型匹配

match除了匹配特定的常量，还能匹配某种类型的所有值；

在scala 中倾向于用这样的模式匹配，而不是isInstanceOf 操作符；

Scala 复制代码

object TestMatch{   
    def main(args:Array[String]):Unit = {
        val value:Any = 20
        //    if(value.isInstanceOf[Int]){
        //      println("Int")
        //    }
        value match {
            case x:Bird => println(x,"bird")
            case x:Int if(x>18) => println(x,"Int")
            case x:Int if(x>18) => println(x,"Int1")
            case x:String => println(x,"String")
            case x:Boolean => println(x,"Boolean")
            case _ => println("unknow type!!")
        }
    }
}
class Bird

4. 数组、元组、集合匹配、映射匹配

元组匹配时case后面的值的个数应与被匹配的元组中数据的个数相同，否则报错。

当有多个条件能匹配到时以最先匹配到的条件为准

Scala 复制代码

//    val arr = Array(1,2,3,4)
//    arr match {
      case x:Array[Int] => println(1)
      case Array(1,2,3,4) => println(2)
      case Array(a,b,c,d) => println(a,b,c,d)
      case Array(1,2,a,b) => println(a,b)
//      case Array(a,b,_,_) => println(a,b)
//      case _ => println("no match!!")
//    }
//    val tp = (1,"zhangsan",20)
//    tp match {
//      case (1,"zhangsan",20) => println("1")
//      case x:(Int,String,Int) => println("2")
//      case (a,b,c) => println(a,b,c)
//      case (a,b,_) => println(a,b)
//      case Tuple3(a,b,c) => println(a,b,c)
//      case _ => println("unknow type")
//  }
//    val list = List(1,2,3,4)
//    list match {
//      case List(1,2,3,4) => println("1")
//      case x:List[Int] => println(x)
//      case List(a,b,c,d) => println(a,b,c,d)
//      case List(a,b,_,_) => println(a,b)
//      case a::b::c::d => println(a,b,c,d)
//      case a::b::c::d::Nil => println(a,b,c,d)
//    }

//    val map = Map("zhangsan"->20,"lisi"->30)
//    map.get("zhangsan1") match {
//      case Some(v) => println(v)
//      case None => println("no value")
//    }