Scala 基础（十三）：Scala 模式匹配

Posted 2020-12-16 qiu-hua

1 match

应用案例

Scala的模式匹配

案例代码完整:
package com.atguigu.base

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

    // 模式匹配，类似于Java的switch语法
    var result = 0
    val c = ‘-‘
    c match {
      case ‘-‘ =>
        result = 1
        println("匹配到-")
      case ‘+‘ =>
        result = -1
        println("匹配到+")
      case ‘%‘ => {  //多行的话，可以换行，可以使用 {} 括起来，也可以不扩
        result = 100
        println("匹配到%")
      }
      case _   => println("没有匹配到...")
    }
    println(result)
  }
}

match的细节和注意事项

1）如果所有case都不匹配，那么会执行case _ 分支，类似于Java中default语句

2）如果所有case都不匹配，又没有写case _ 分支，那么会抛出MatchError

3）每个case中，不用break语句，自动中断case

4）可以在match中使用其它类型，而不仅仅是字符

 

5）=> 等价于 java swtich 的 :

6）=> 后面的代码块到下一个 case， 是作为一个整体执行，可以使用{} 扩起来，也可以不扩。

2 守卫

 如果想要表达匹配某个范围的数据，就需要在模式匹配中增加条件守卫

应用案例

for (ch <- "+-3!") {
var sign = 0
var digit = 0
ch match {
case ‘+‘ => sign = 1
case ‘-‘ => sign = -1
// 说明..
case _ if ch.toString.equals("3") => digit = 3
case _ => sign = 2
}
println(ch + " " + sign + " " + digit)
}

3 模式中的变量

如果在case关键字后跟变量名，那么match前表达式的值会赋给那个变量

应用案例

val ch = ‘V‘
ch match {
case ‘+‘ => println("ok~")
case mychar => println("ok~" + mychar)
case _ => println ("ok~~")
}

4 类型匹配

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

应用案例

// 类型匹配, obj 可能有如下的类型
val a = 7
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 result = obj match {
case a : Int => a
case b : Map[String, Int] => "对象是一个字符串-数字的Map集合"
case c : Map[Int, String] => "对象是一个数字-字符串的Map集合"
case d : Array[String] => "对象是一个字符串数组"
case e : Array[Int] => "对象是一个数字数组"
case f : BigInt => Int.MaxValue
case _ => "啥也不是"
}
println(result)

类型匹配注意事项

1）Map[String, Int] 和Map[Int, String]是两种不同的类型，其它类推。

2）在进行类型匹配时，编译器会预先检测是否有可能的匹配，如果没有则报错.

val obj = 10
val result = obj match {
case a : Int => a
case b : Map[String, Int] => "Map集合"
case _ => "啥也不是"
}

3）一个说明:

val result = obj match {

 

case i : Int => i

} case i : Int => i 表示 将 i = obj (其它类推)，然后再判断类型

4）如果 case _ 出现在match 中间，则表示隐藏变量名，即不使用,而不是表示默认匹配。

// 类型匹配, obj 可能有如下的类型
val a = 7
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 result = obj match {
case a : Int => a
case _ : BigInt => Int.MaxValue //看这里!
case b : Map[String, Int] => "对象是一个字符串-数字的Map集合"
case c : Map[Int, String] => "对象是一个数字-字符串的Map集合"
case d : Array[String] => "对象是一个字符串数组"
case e : Array[Int] => "对象是一个数字数组"
case _ => "啥也不是"
}
println(result)