Scala的模式匹配

一、基本语法

    匹配的值 match {
        case 选项 =>
            // 代码
        case 选项 =>
           //
            ...
        case _ =>
    }

二、模式守卫

case判断时带上if进行守卫

例子
case a: Int if a > 10 => println(a + 10)

三、模式匹配类型

3.1 变量和常量

1. aa 和Ba的区别

aa是新声明的, 只能在这个case内使用，相当于case_
变量是大写字母开头, scala任务这个变量是一个常量, 必须是已经定义好的常量

2. 匹配常量

1. 首字母大写
2. 用反引号引起来的 ``

例子
        val a = 20
        a match {
//            case a => println(aA)  //此a是变量，能接受任何值
//            case `a` => println(aA)  //此a是20
            case _ =>    
        }

3.2 模式匹配的返回值

任何的语法结构都有值!
模式匹配也也有值, 他的值就是匹配成功的那个case的最后一行代码的值

例子
        val a = 10
        val b = 20
        val op = StdIn.readLine("请输入一个运算符: ")
        val r:Int = op match {
            case "+" =>
                a + b
            case "-" =>
                a - b
            case "*" =>
                a * b
            case "/" =>
                a / b
            case _ => -1   //这里的-1尽量和前面返回值类型保持一致
        }
        println(r)

3.3 匹配类型

case时，定义成带类型的变量

例子
        val a: Any = 100 // ""  true
        
        a match {
            case a: Int if a > 10 => println(a + 10)
            case s: String => println(s.toUpperCase())
            case b: Boolean => println(b)
            case _ =>
        }

3.4 泛型的类型匹配

数组在scala中表面用到了泛型, 实际不是泛型

例子
        //val arr: Array[Int] = Array[String]("aaa")
       //val arr: Any = Array[String]("aaa")
        //val arr: List[String] = List[String]("aaa")
        val arr: Any = List[String]("aaa")
        
        arr match {
            //            case a: Array[Int] => println("Array[Int]") // arr为array[Int]可以匹配到
            //            case a: Array[Double] => println("Array[Double]")  //这里为double，匹配不到，可以把arr改成Any
            // 匹配任意数组
            //            case a: Array[_] => println("Array[_]")
		}

3.5 匹配数组

模式匹配深入到集合的内部:

例子
        val arr = Array(2, 2, 20, 10, 1)
        
        arr match {
            /*case Array(2, 2, a, b) =>  //匹配array前两个为2,2的共4个长度的数组
//                println("Array(1, 2, _, _)") //ab也可以用_代替
               println(a, b)*/   

            /*case Array(a, b, _, d)  =>
                println(a)*/

            /*case Array(2, 2, _*) =>         //  _*  任意长度，任意字符的数组
                println("Array(2, 2, _*)")*/

            case Array(2, 2, abc@_*) =>
                println(abc.toList) //ABC输出为vector 
        }

3.6 匹配元组

例子
          val t: (String, Int) = ("lisi", 20)
        
        t match {
//            case (name, age) => println(name)
//            case (name: String, age) => println(name)
            case (name: Int, age) => println(name)   //这里改成Int，在编译的时候就不匹配了，但是上面定义的t为Any，会在运行后报错
        }            

3.7 匹配列表

例子
        val list = List(10, 20, 30, 40)
        
        list match {
            //            case List(a, b, c, d) =>
            //                println(s"List(a, b, $c, $d)")
            
            //            case List(10, abc@_*) =>
            //                println(abc)
            case a :: b :: c :: d :: Nil =>
                println(d)
            case a :: b :: c => // 最后一个一定是List集合
                println(a)
                println(b)
                println(c)
        }

3.8 匹配对象(option)

例子
class A(val age: Int, val name: String)

object People {
    def unapply(pp: A): Option[(Int, String)] =
        if (pp != null)
            Some(pp.age, pp.name)
        else None
}

object OptionDemo{
    def main(args: Array[String]): Unit = {
        val p = new A(10, "zhiling")
        
        p match {
            case People(age, name) => println(age, name)
            case _ =>
        }
    }
}

四、样例类

例子

case class User1(age: Int, var name: String)
object CaseDeo1 {
    def main(args: Array[String]): Unit = {
        val user: User1 = User1(10, "lisi")
        user match {
            case User1(age, name) => println(age)
        }
    }
}

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

例子

    def foo() = (10, "lisi")
    
    def foo1() = Array(1, 2, 3, 4, 5)



        val (a, b): (Int, String) = foo()
        println(a)
        println(b)


        val Array(a, b, rest@_*) = foo1()
        println(a)
        println(b)
        println(rest)

六、for循环中的模式匹配

例子
        val list = List((1,2 ), (10, 20), (100, 200))
        /*for (kv <- list) {    //原版
            println(kv._1)
        }*/
        
        for((k, 20) <- list){  //模式匹配版
            println(k)
        }

七、偏函数

用一对大括号括起来的一个或多个case语句就是偏函数

例子

        val map = Map("a"-> 97,"b"-> 98,"c"-> 99)
        map.foreach(x => {
            println(x._1)
            println(x._2)
        })
        map.foreach({
            case (k, v) => println(k)
        })
        

        val list = List(
            ("a", ("b", (1, "c"))),
            ("aa", ("bb", (2, "cc"))))
        val list2 = list.map {            
            case (a, (b, (c, d))) => c
        }
        println(list2)