Scala-22：模式匹配

Scala-22：模式匹配

Scala 中的模式匹配类似于 Java 中的 switch 语法 ，只是用法更加的宽泛

一、概念

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

def main(args: Array[String]): Unit = { 
 
    var a: Int = 10 
    var b: Int = 20 
    var operator: Char = 'd' 
 
    var result = operator match { 
      case '+' => a + b 
      case '-' => a - b 
      case '*' => a * b 
      case '/' => a / b 
      case _ => "illegal" 
      } 
 
    println(result) 
  } 

1：说明

（1）如果所有 case 都不匹配，那么会执行 case _ 分支，类似于 Java 中 default 语句，若此时没有 case _ 分支，那么会抛出 MatchError。

（2）每个 case 中，不需要使用 break 语句，自动中断 case。

（3）match case 语句可以匹配任何类型，而不只是字面量。

（4）=> 后面的代码块，直到下一个 case 语句之前的代码是作为一个整体执行，可以使用{}括起来，也可以不括。

二、模式守卫

1：说明

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

def main(args: Array[String]): Unit = { 
 
        def abs(x: Int) = x match { 
            case i: Int if i >= 0 => i 
            case j: Int if j < 0 => -j 
            case _ => "type illegal" 
        } 
 
        println(abs(-5)) 
    }

三、模式匹配类型

1：匹配常量

Scala 中，模式匹配可以匹配所有的字面量，包括字符串，字符，数字，布尔值等等。

def main(args: Array[String]): Unit = { 
 
        println(describe(6)) 
 
    } 
 
    def describe(x: Any) = x match { 
 		
        // 匹配数字
        case 5 => "Int five" 
 
        // 匹配字符串
        case "hello" => "String hello" 
 
        // 匹配布尔值
        case true => "Boolean true" 
 
        // 匹配字符
        case '+' => "Char +" 
 
    }

3：匹配类型

需要进行类型判断时，可以使用前文所学的 isInstanceOf[T]和 asInstanceOf[T]，也可使用模式匹配实现同样的功能。

def describe(x: Any) = x match { 
 
        case i: Int => "Int" 
        case s: String => "String hello" 
        case m: List[_] => "List" 
        case c: Array[Int] => "Array[Int]" 
        case someThing => "something else " + someThing 
    } 
 
    def main(args: Array[String]): Unit = { 
 
        //泛型擦除 
        println(describe(List(1, 2, 3, 4, 5))) 
 
        //数组例外，可保留泛型 
        println(describe(Array(1, 2, 3, 4, 5, 6))) 
        println(describe(Array("abc"))) 
    } 

3：匹配数组

scala 模式匹配可以对集合进行精确的匹配，例如匹配只有两个元素的、且第一个元素为 0 的数组。

ef main(args: Array[String]): Unit = { 
 
        for (arr <- Array(Array(0), Array(1, 0), Array(0, 1, 0), Array(1, 1, 0),Array(1, 1, 0, 1), Array("hello", 90))) { 
             
 			// 对一个数组集合进行遍历
            val result = arr match { 
                //匹配 Array(0) 这个数组 
                case Array(0) => "0" 
 
                //匹配有两个元素的数组，然后将将元素值赋给对应的 x,y 
                case Array(x, y) => x + "," + y 
 
                //匹配以 0 开头和数组 
                case Array(0, _*) => "以 0 开头的数组" 
 
                case _ => "something else" 
            } 
 
            println("result = " + result) 
        } 
    } 

4：匹配列表

def main(args: Array[String]): Unit = { 
 
        val list: List[Int] = List(1, 2, 5, 6, 7) 
 
        list match { 
            case first :: second :: rest => println(first + "-" + second + "-" + rest) 
            case _ => println("something else") 
        } 
    } 

5：匹配元组

def main(args: Array[String]): Unit = { 
 
        //对一个元组集合进行遍历 
        for (tuple <- Array((0, 1), (1, 0), (1, 1), (1, 0, 2))) { 
 
            val result = tuple match { 
                case (0, _) => "0 ..." //是第一个元素是 0 的元组 
                case (y, 0) => "" + y + "0" // 匹配后一个元素是 0 的对偶元组 
                case (a, b) => "" + a + " " + b 
                case _ => "something else" //默认 
 
            } 
            println(result) 
        } 
    } 

6：匹配对象及样例类

class User(val name: String, val age: Int)


object User{ 
 
    def apply(name: String, age: Int): User = new User(name, age) 
 
    def unapply(user: User): Option[(String, Int)] = { 
        if (user == null) 
            None 
        else 
            Some(user.name, user.age) 
    } 
} 
 
 
 def main(args: Array[String]): Unit = { 
        val user: User = User("zhangsan", 11) 
        val result = user match { 
            case User("zhangsan", 11) => "yes" 
            case _ => "no" 
        } 
 
        println(result) 
    } 

四、变量声明中的模式匹配

case class Person(name: String, age: Int) 
 

    def main(args: Array[String]): Unit = { 
 
        val (x, y) = (1, 2) 
        println(s"x=$x,y=$y") 
 
        val Array(first, second, _*) = Array(1, 7, 2, 9) 
        println(s"first=$first,second=$second") 
 
        val Person(name, age) = Person1("zhangsan", 16) 
        println(s"name=$name,age=$age") 
	}

五、for 表达式中的模式匹配

def main(args: Array[String]): Unit = { 
 
        val map = Map("A" -> 1, "B" -> 0, "C" -> 3) 
        for ((k, v) <- map) { //直接将 map 中的 k-v 遍历出来 
            println(k + " -> " + v) //3 个 
        } 
        println("----------------------") 
 
        //遍历 value=0 的 k-v ,如果 v 不是 0,过滤 
        for ((k, 0) <- map) { 
            println(k + " --> " + 0) // B->0 
        } 
 
        println("----------------------") 
        //if v == 0 是一个过滤的条件 
        for ((k, v) <- map if v >= 1) { 
            println(k + " ---> " + v) // A->1 和 c->33 
        } 
    }