Scala-模式匹配

骑猪看日落 2022-09-01 13:58 201阅读 0赞

# 模式匹配 #

Scala 中的模式匹配**类似于 Java 中的 switch 语法**，但是 scala 从语法中补充了更多的功能,所以更加强大。

## 基本语法 ##

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

object TestMatchCase { 
        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)如果所有 case 都不匹配,那么会执行 case \_ 分支,类似于 Java 中 default 语句,若此时没有 case \_ 分支,那么会抛出 MatchError。

(2)每个 case 中,不需要使用 break 语句,自动中断 case。

(3)match case 语句可以匹配任何类型,而不只是字面量。

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

object TestPatternMatchBase { 
    
        def main(args: Array[String]): Unit = { 
            // 1、基本定义语法
            val x = 2
            val y = x match { 
                case 1 => "one"
                case 2 => "two"
                case 3 => "three"
                case _ => "other"
            }
            println(y) // two
    
            // 2、示例： 用模式匹配实现简单的二院运算
            val a = 11
            val b = 99
    
            def matchDualOp(op: Char) = { 
                op match { 
                    case '+' => a + b
                    case '-' => a - b
                    case '*' => a * b
                    case '/' => a / b
                    case '%' => a % b
                    case  _ => -1
                }
            }
    
            println(matchDualOp('+')) // 110
            println(matchDualOp('-')) // -88
            println(matchDualOp('/')) // 0
            println(matchDualOp(')')) // -1
        }
    }

## 模式守卫 ##

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

object TestPatternMatchBase { 
    
        def main(args: Array[String]): Unit = { 
            // 3、模式守卫
            // 求一个整数的绝对值
            def abs(num: Int): Int = { 
                num match { 
                    case i if i >= 0 => i
                    case i if i < 0 => -i
                }
            }
    
            println(abs(-11)) // 11
            println(abs(13))  // 13
        }
    }

## 模式匹配类型 ##

### 匹配常量 ###

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

object TestMatchTypes { 
    
        def main(args: Array[String]): Unit = { 
            // 匹配常量
            def descConst(x: Any): String = { 
                x match { 
                    case 1 => "Int one"
                    case "hello" => "String hello"
                    case true => "Boolean true"
                    case '+' => "Char +"
                    case _ => "other " + x
                }
            }
            println(descConst("hello")) // String hello
            println(descConst('+'))     // Char +
            println(descConst(0.3))     // other 0.3
        }
    }

### 匹配类型 ###

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

。

object TestMatchTypes { 
    
        def main(args: Array[String]): Unit = { 
            // 匹配类型
            def descType(x: Any): String = { 
                x match { 
                    case i: Int => "Int " + i
                    case s: String => "String " + s
                    case list: List[String] => "List " + list
                    case array: Array[Int] => "Array[Int] " + array.mkString(",")
                    case _ => "Something else " + x
                }
            }
            println(descType(35)) // Int 35
            println(descType("hello")) // String hello
            println(descType(List("hello", "word"))) // List List(hello, word)
            // 这里因为集合在进行匹配的时候会进行 “泛型擦除” 的，而Array不是直接属于集合，而是通过隐式转换的，所以Array可以直接判断出类型
            println(descType(List(1, 2))) // List List(1, 2)
            println(descType(Array("hi", "h"))) // Something else [Ljava.lang.String;@1cd072a9
            println(descType(Array(1, 2))) // Array[Int] 1,2
        }
    }

### 匹配数组 ###

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

object TestMatchTypes { 
    
        def main(args: Array[String]): Unit = { 
            // 匹配数组
            for (arr <- List(
                Array(0), // Array(0)
                Array(1, 0), // Array(1, 0)
                Array(0, 1, 0), // 以0开头的数组
                Array(1, 1, 0), // 中间为1的三元素数组
                Array(2, 3, 5, 6), // 其他
                Array("hello", 1, 50) // 中间为1的三元素数组
            )) { 
                val result = arr match { 
                    case Array(0) => "Array(0)"
                    case Array(1, 0) => "Array(1, 0)"
                    case Array(x, y) => "Array: " + x + ", " + y // 匹配两元素数组
                    case Array(0, _*) => "以0开头的数组"
                    case Array(x, 1, y) => "中间为1的三元素数组"
                    case _ => "其他"
                }
                println(result)
            }
        }
    }

### 匹配列表 ###

object TestMatchTypes { 
    
        def main(args: Array[String]): Unit = { 
            // 匹配列表
            // 方式一
            for (list <- List(
                List(0), // List(0)
                List(1, 0), // List(x, y)
                List(0, 0, 0), // List(0, ...)
                List(1, 1, 0), // Something else
                List(88), // List(x)
                List("hello") // List(x)
            )) { 
                val result = list match { 
                    case List(0) => "List(0)"
                    case List(x, y) => "List(x, y)"
                    case List(0, _*) => "List(0, ...)"
                    case List(a) => "List(x)"
                    case _ => "Something else"
                }
                println(result)
            }
    
            println("--------------------------")
            // 方式二
            val list1 = List(1, 2, 5, 7, 24)
            val list2 = List(1)
    
            def descListSecond(list: List[Any]): Unit = { 
                list match { 
                    case first :: second :: rest => println(s"first: $first, second: $second, rest: $rest")
                    case _ => println("Something else")
                }
            }
            descListSecond(list1) // first: 1, second: 2, rest: List(5, 7, 24)
            descListSecond(list2) // Something else
    
        }
    }

### 匹配元组 ###

object TestMatchTuple { 
    
        def main(args: Array[String]): Unit = { 
    
            // 匹配元组
            // 1、基本的匹配
            for (tuple <- List(
                (0, 1), // (a, b)
                (0, 0), // (a, b)
                (0, 1, 0), // (a, 1, b)
                (0, 1, 1), // (a, 1, b)
                (1, 23, 56), // Something else
                ("hello", true, 0.5) // Something else
            )) { 
                val str = tuple match { 
                    case (a, b) => "(a, b)"
                    case (0, _) => "(0, _)"
                    case (a, 1, b) => "(a, 1, b)"
                    case _ => "Something else"
                }
                println(str)
            }
    
            println("=============================")
    
            // 2、在变量声明时匹配
            val (x, y) = (10, "hello")
            println(s"x: $x, y: $y")  // x: 10, y: hello
    
            val List(first, second, _*) = List(23, 15, 9, 78)
            println(s"first: $first, second: $second") // first: 23, second: 15
    
            val fir :: sec :: rest = List(23, 15, 9, 78)
            println(s"first: $fir, second: $sec, rest: $rest") // first: 23, second: 15, rest: List(9, 78)
    
            println("=============================")
    
            // 3、在for推导式中进行模式匹配
            val list: List[(String, Int)] = List(("a", 12), ("b", 35), ("c", 27))
    
            // 3.1 原本的遍历方式
            for (elem <- list) { 
                println(elem._1 + " " + elem._2)
    // a 12
    // b 35
    // c 27
            }
            println("-------------")
    
            // 3.2 将List的元素直接定义为元组，对变量赋值
            for ((word, count) <- list) { 
                println(word + " " + count)
    // a 12
    // b 35
    // c 27
            }
            println("-------------")
    
            // 3.3 不考虑某个位置的变量，只遍历key或者value
            for ((word, _) <- list) { 
                println(word)
    // a
    // b
    // c
            }
            println("-------------")
    
            // 3.4 可以指定某个位置的值必须是多少
            for (("a", count) <- list) { 
                println(count) // 12
            }
        }
    }

### 匹配对象及样例类 ###

**匹配对象**

object TestMatchObject { 
    
        def main(args: Array[String]): Unit = { 
            val alice = new Student("alice", 18)
            val bobo = new Student("bobo", 18)
    
            // 针对对象实例内容进行匹配
            def matchHandle(student: Student): Unit = { 
                val result = student match { 
                    case Student("alice", 18) => "alice 18"
                    case _ => "else"
                }
                println(result)
            }
    
            matchHandle(alice) // alice 18
            matchHandle(bobo)  // else
        }
    }
    
    // 定义类
    class Student(val name: String, val age: Int)
    
    // 定义伴生对象
    object Student { 
    
        def apply(name: String, age: Int): Student = new Student(name, age)
    
        // 必须实现一个unapply方法，用来对对象属性进行拆解
        def unapply(student: Student): Option[(String, Int)] = { 
            if (student == null) { 
                None
            } else { 
                Some((student.name, student.age))
            }
        }
    }

val alice = Student(“alice”, 18),该语句在执行时,实际调用的是 User 伴生对象中的apply 方法,因此不用 new 关键字就能构造出相应的对象。

当将 Student(“alice”, 18)写在 case 后时\[case Student(“alice”, 18) => “alice 18”\],会默认调用 unapply 方法(对象提取器),student 作为 unapply 方法的参数,unapply 方法将 student 对象的 name 和 age 属性提取出来,与 Student(“alice”, 18)中的属性值进行匹配

case 中对象的 unapply 方法(提取器)返回 Some,且所有属性均一致,才算匹配成功,属性不一致,或返回 None,则匹配失败。

若只提取对象的一个属性,则提取器为 unapply(obj:Obj):Option\[T\]

若提取对象的多个属性,则提取器为 unapply(obj:Obj):Option\[(T1,T2,T3…)\]

若提取对象的可变个属性,则提取器为 unapplySeq(obj:Obj):Option\[Seq\[T\]\]

**样例类**

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

1 样例类仍然是类,和普通类相比,只是其自动生成了伴生对象,并且伴生对象中自动提供了一些常用的方法,如apply、 unapply、 toString、 equals、 hashCode 和 copy。

2 样例类是为模式匹配而优化的类,因为其默认提供了 unapply 方法,因此,样例类可以直接使用模式匹配,而无需自己实现 unapply 方法。

3 构造器中的每一个参数都成为 val,除非它被显式地声明为 var(不建议这样做)

object TestMatchCaseClass { 
    
        def main(args: Array[String]): Unit = { 
            val alice = new Student("alice", 18)
            val bobo = new Student("bobo", 18)
    
            // 针对对象实例内容进行匹配
            def matchHandle(student: Student): Unit = { 
                val result = student match { 
                    case Student("alice", 18) => "alice 18"
                    case _ => "else"
                }
                println(result)
            }
    
            matchHandle(alice) // alice 18
            matchHandle(bobo)  // else
        }
    }
    
    // 定义样例类
    case class Student1(name: String, age: Int)

## 偏函数中的模式匹配 ##

偏函数也是函数的一种,通过偏函数我们可以方便的对输入参数做更精确的检查。例如该偏函数的输入类型为 List\[Int\],而我们需要的是第一个元素是 0 的集合,这就是通过模式匹配实现的。

定义：

val second: PartialFunction[List[Int], Option[Int]] = { 
    	case x :: y :: _ => Some(y)
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NsZWFybHhq_size_16_color_FFFFFF_t_70]

注:该偏函数的功能是返回输入的 List 集合的第二个元素

原理：

上述代码会被 scala 编译器翻译成以下代码,与普通函数相比,只是多了一个用于参数检查的函数——isDefinedAt,其返回值类型为 Boolean。

val second = new PartialFunction[List[Int], Option[Int]] { 
        //检查输入参数是否合格
        override def isDefinedAt(list: List[Int]): Boolean = list match { 
            case x :: y :: _ => true
            case _ => false
        }
        //执行函数逻辑
        override def apply(list: List[Int]): Option[Int] = list match { 
        	case x :: y :: _ => Some(y)
        }
    }

使用：

偏函数不能像 second(List(1,2,3))这样直接使用,因为这样会直接调用 apply 方法,而应该调用 applyOrElse 方法,如下

second.applyOrElse(List(1,2,3), (_: List[Int]) => None)

applyOrElse 方法的逻辑为 if (ifDefinedAt(list)) apply(list) else default。如果输入参数满足条件,即 isDefinedAt 返回 true,则执行 apply 方法,否则执行 defalut 方法,default 方法为参数不满足要求的处理逻辑。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NsZWFybHhq_size_16_color_FFFFFF_t_70]: /images/20220829/63d95a149b1249d9b011fabc35cc0266.png