Scala入门系列(10)-Scala之模式匹配

朴灿烈づ我的快乐病毒、 2023-10-10 12:33 77阅读 0赞

## 模式匹配 ##

### match ###

Scala中的模式匹配类似于Java中的switch语法，但是更加强大。

模式匹配语法中，采用match关键字声明，每个分支采用case关键字进行声 明，当需要匹配时，会从第一个case分支开始，如果匹配成功，那么执行对 应的逻辑代码，如果匹配不成功，继续执行下一个分支进行判断。如果所有 case都不匹配，那么会执行case \_ 分支，类似于Java中default语句。

object MatchTest {
        
      def main(args: Array[String]): Unit = {
        
        println(matchTest(1))
      }
      def matchTest(x: Int): String = x match {
        
        case 1 => "one"
        case 2 => "two"
        case _ => "many"
      }
    }

**注意事项**:

1.  如果所有case都不匹配，那么会执行case \_ 分支，类似于Java中default语句。
2.  如果所有case都不匹配，又没有写case \_ 分支，那么会抛出MatchError。
3.  每个case中，不用break语句，自动中断case。
4.  可以在match中使用其它类型，而不 仅仅是字符。
5.  => 等价于 java swtich 的 :
6.  => 后面的代码块到下一个 case， 是作为一个整体执行，可以使用\{\} 扩起 来，也可以不扩。

### 守卫 ###

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

case _ if (x == 3) => "3333"

### 模式中的变量 ###

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

case _myNum => "a" + _myNum

### 类型匹配 ###

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

val a = 4
        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.  在进行类型匹配时，编译器会预先检测是否有可能的匹配，如果没有则报错。
3.  如果 case \_ 出现在match 中间，则表示隐藏变量名，即不使用,而不是表 示默认匹配。

### 匹配数组 ###

**注意事项**:

1.  Array(0) 匹配只有一个元素且为0的数组。
2.  Array(x,y) 匹配数组有两个元素，并将两个元素赋值为x和y。当然可以依次 类推Array(x,y,z) 匹配数组有3个元素的等等…
3.  Array(0,\_\*) 匹配数组以0开始

### 对象匹配 ###

case中对象的unapply方法(对象提取器)返回Some集合则为匹配成功，返回none集合则为匹配失败。

object MatchTest {
        
      def main(args: Array[String]): Unit = {
        
        val number: Double = 36.0
        number match {
        
          case Square(n) => println(n)
          case _ => println("nothing matched")
        }
      }
    }
    object Square {
        
      def unapply(z: Double): Option[Double] = Some(math.sqrt(z))
    
      def apply(z: Double): Double
      = z * z
    }

1.  构建对象时apply会被调用 ，比如 val n1 = Square(5)
2.  当将 Square(n) 写在 case 后时\[case Square(n) => xxx\]，会默认调用 unapply 方法(对象提取器)
3.  number 会被 传递给def unapply(z: Double) 的 z 形参
4.  如果返回的是Some集合，则unapply提取器返回的结果会返回给 n 这个形 参
5.  case中对象的unapply方法(提取器)返回some集合则为匹配成功
6.  返回none集合则为匹配失败

### 变量声明中的模式 ###

match中每一个case都可以单独提取出来，意思是一样的。

val (x, y) = (1, 2) // 元组写法
        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, _*) = arr // 提出arr的前两个元素
        println(first, second)

### for表达式中的模式 ###

for循环也可以进行模式匹配。

val map = Map("A" -> 1, "B" -> 0, "C" -> 3)
        for ((k, v) <- map) {
        
          println(k + " -> " + v)
        }
        for ((k, 0) <- map) {
        
          println(k + " --> " + 0)
        }
        for ((k, v) <- map if v == 0) {
        
          println(k + " ---> " + v)
        }

## 样例类（模板类） ##

abstract class Amount
    
    case class Dollar(value: Double) extends Amount
    
    case class Currency(value: Double, unit: String) extends Amount
    
    case object NoAmount extends Amount
    
    object Test011 {
        
      def main(args: Array[String]): Unit = {
        
        for (amt <- Array(Dollar(1000.0), Currency(1000.0, "RMB"), NoAmount)) {
        
          val result = amt match {
        
            // 对象提取匹配，并提取属性
            case Dollar(v) => "$" + v
            case Currency(v, u) => v + " " + u
            case NoAmount => ""
          }
          println(amt + ": " + result)
        }
      
        // 样例类的copy方法和带名参数
        val amt = Currency(29.95, "RMB")
        val amt1 = amt.copy() //创建了一个新的对象，但是属性值一样
        val amt2 = amt.copy(value = 19.95) //创建了一个新对象，但是修改了货币单位
        val amt3 = amt.copy(unit = "英镑") //..
        println(amt)
        println(amt1)
        println(amt3)
      }
    }

1.  样例类仍然是类，用case关键字进行声明。
2.  样例类是为模式匹配而优化的类，
3.  构造器中的每一个参数都成为val——除非它被显式地声明为var（不建议这样做）。
4.  在样例类对应的伴生对象中提供apply方法让你不用new关键字就能构造出相应 的对象。
5.  提供unapply方法让模式匹配可以工作，
6.  将自动生成toString、equals、hashCode和copy方法(有点类似模板类，直接给生成，供程序员使用)。
7.  除上述外，样例类和其他类完全一样。你可以添加方法和字段，扩展它们。

### case语句的中置(缀)表达式 ###

什么是中置表达式？1 + 2，这就是一个中置表达式。如果unapply方法产出一个 元组，你可以在case语句中使用中置表示法。比如可以匹配一个List序列。

List(1, 2, 3, 4, 5) match {
        
          // 两个元素间::叫中置表达式,至少first，second两个匹配才行.
          // first 匹配第一个 second 匹配第二个, rest 匹配剩余部分
          case first :: second :: rest => println(first + second + rest.length)
          case _ => println("匹配不到...")
        }

### 匹配嵌套结构 ###

操作原理类似于正则表达式。

### 密封类 ###

如果想让case类的所有子类都必须在申明该类的相同的源文件中定义，可以将 样例类的通用超类声明为sealed，这个超类称之为密封类。密封就是不能在其他文件中定义子类。