Scala模式匹配详解

置顶 已于 2022-10-09 16:51:34 修改
阅读量1w 收藏 9
点赞数 2
分类专栏： 学无止境 文章标签： scala spark 开发语言
于 2022-10-04 14:27:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61532500/article/details/127161938
版权

前言

Scala 中的模式匹配类似于 Java 中的 switch 语法

  • Java中的switch语法，default就是都不符合
int i = 10
switch (i) {
    case 10 :
    	System.out.println("10");
    	break;
    case 20 : 
    	System.out.println("20");
    	break;
    default : 
    	System.out.println("other number");
    	break;
}

但是 scala 从语法中补充了更多的功能，所以更加强大

1.基本语法

模式匹配语法中，采用 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 Test05_Extents {
    def main(args: Array[String]): Unit = {

        var a: Int = 10
        var b: Int = 20

        def matchDualOp(op: Char):Any = op match {
            case '+' => a + b
            case '-' => a - b
            case '*' => a * b
            case '/' => a / b
            case  _  => "非法运算符"
        }
        println(matchDualOp('+'))
    }
}

2.模式守卫

  • 说明

    如果想要表达匹配某个范围的数据，就需要在模式匹配中增加条件守卫。符合这样范围的值，就会匹配哪一个case

  • 案例实操

object TestMatchGuard {
    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))
    }
}

3.模式匹配类型

3.1 匹配常量

  • 说明

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

  • 实操
object TestMatchVal {
    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.2 匹配类型

  • 说明

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

  • 案例实操
object TestMatchClass {
    def describe(x: Any) = x match {
        case i: Int => "Int"
        case s: String => "String hello"
        case m: List[String] => "List"
        case c: Array[Int] => "Array[Int]"
        // 如果不需要拿到值，就直接_就行，但是如果需要拿到当前值
        case a => "something else " + a
    }
    def main(args: Array[String]): Unit = {
        //泛型擦除
        println(describe((1, 2, 3, 4, 5)))
        //数组例外，可保留泛型
        println(describe(Array(1, 2, 3, 4, 5, 6)))
        println(describe(Array("abc")))
    }
}

Array不存在泛型擦除，而List存在，也即List[Int]与List[String]是一样的，都能互相匹配

3.3 匹配数组

  • 说明

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

判断匹配的顺序是从上到下

  • 案例实操
object TestMatchArray {
    def 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 {
                case Array(0) => "0" //匹配 Array(0) 这个数组
                case Array(x, y) => x + "," + y //匹配有两个元素的数组，然后将将元素值赋给对应的 x,y
                case Array(0, _*) => "以 0 开头的数组" //匹配以 0 开头和数组
                case Array(x,1,y) => "中间为1的三元素数组"
                case _ => "something else"
            }
            println("result = " + result)
        }
    }
}

3.4 匹配列表

  • 方式一
object TestMatchList {
    def main(args: Array[String]): Unit = {
        // list 是一个存放 List 集合的数组
        // 请思考，如果要匹配 List(88) 这样的只含有一个元素的列表,并原值返回.应该怎么写
        for (list <- List(List(0), List(1, 0), List(0, 0, 0), List(1,0,0), List(88))) {
            val result = list match {
                case List(0) => "0" // 匹配 List(0)
                case List(x, y) => x + "," + y // 匹配有两个元素的 List
                case List(0, _*) => "0 ..."
                case _ => "something else"
            }
            println(result)
        }
    }
}
  • 方式二

利用了List的特殊的运算符::

object TestMatchList {
    def main(args: Array[String]): Unit = {
        val list: List[Int] = List(1, 2, 5, 6, 7, 24)
        list match {
            // 匹配存在第一个元素与第二个元素的，后面是一个列表的数据
            case first :: second :: rest => println(first + "-" + second + "-" + rest)
            case _ => println("something else")
        }
    }
}

控制台打印
// 第一个元素是1，第二个元素是2，后面rest列表是List(5, 6, 7, 24)
1-2-List(5, 6, 7, 24)

3.5 匹配元组

object TestMatchTuple {
    def main(args: Array[String]): Unit = {
        //对一个元组集合进行遍历
        for (tuple <- List((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)
        }
    }
}

扩展案例

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

    //特殊的模式匹配 1 打印元组第一个元素
    for (elem <- Array(("a", 1), ("b", 2), ("c", 3))) {
        println(elem._1)
    }
    for ((word,count) <- Array(("a", 1), ("b", 2), ("c", 3))) {
        println(word)
    }
    for ((word,_) <- Array(("a", 1), ("b", 2), ("c", 3))) {
        println(word)
    }
    for (("a",count) <- Array(("a", 1), ("b", 2), ("c", 3))) {
        println(count)
    }
    println("--------------")
    //特殊的模式匹配 2 给元组元素命名
    var (id,name,age): (Int, String, Int) = (100, "zs", 20)
    println((id,name,age))
    println("--------------")
    //特殊的模式匹配 3 遍历集合中的元组，给 count * 2
    var list: List[(String, Int)] = List(("a", 1), ("b", 2), ("c", 3))
    //println(list.map(t => (t._1, t._2 * 2)))
    println(
        list.map{
            case (word,count)=>(word,count*2)
        }
    )
    var list1 = List(("a", ("a", 1)), ("b", ("b", 2)), ("c", ("c", 3)))
    println(
        list1.map{
            case (groupkey,(word,count))=>(word,count*2)
        }
    )
}

3.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)
    }
}	
object TestMatchUnapply {
    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)
    }
}
  • 小结
    • val user = User(“zhangsan”,11)，该语句在执行时，实际调用的是 User 伴生对象中的apply 方法，因此不用 new 关键字就能构造出相应的对象。
    • 当将 User("zhangsan", 11)写在 case 后时[case User(“zhangsan”, 11) => “yes”]，会默认调用unapply方法(对象提取器)，user 作为 unapply 方法的参数，unapply 方法 将 user 对象的 name 和 age 属性提取出来，与 User(“zhangsan”, 11)中的属性值进行匹配
    • 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)

  • 说明

    • 样例类仍然是类，和普通类相比，只是其自动生成了伴生对象，并且伴生对象中 自动提供了一些常用的方法，如 apply、unapply、toString、equals、hashCode 和 copy。
    • 样例类是为模式匹配而优化的类，因为其默认提供了 unapply 方法，因此，样例 类可以直接使用模式匹配，而无需自己实现 unapply 方法。
    • 构造器中的每一个参数都成为 val，除非它被显式地声明为 var（不建议这样做）

  • 实操

    上述匹配对象的案例使用样例类会节省大量代码

case class User(name: String, age: Int)
object TestMatchUnapply {
    
    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)
    }
}

4.变量声明中的模式匹配

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

object TestMatchVariable {
    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")
    }
}

5.for 表达式中的模式匹配

object TestMatchFor {
    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
        }
    }
}

6.偏函数中的模式匹配(了解)

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

  • 偏函数定义
val second: PartialFunction[List[Int], Option[Int]] = {
    case x :: y :: _ => Some(y)
}

在这里插入图片描述

注：该偏函数的功能是返回输入的 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 方法 为参数不满足要求的处理逻辑。

  • 案例实操

    • 需求

    将该 List(1,2,3,4,5,6,"test")中的 Int 类型的元素加一，并去掉字符串。

    def main(args: Array[String]): Unit = {
    val list = List(1,2,3,4,5,6,"test")
    val list1 = list.map {
        a =>
        a match {
            case i: Int => i + 1
            case s: String =>s + 1
        }
    }
    println(list1.filter(a=>a.isInstanceOf[Int]))
}
    • 实操
    1. 方法一：
    List(1,2,3,4,5,6,"test").filter(_.isInstanceOf[Int]).map(_.asInstanceOf[Int] + 1).foreach(println)
    1. 方法二：
    List(1, 2, 3, 4, 5, 6, "test").collect { case x: Int => x + 1 }.foreach(println)
楚生辉
关注
  • 2
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Scala--模式匹配
别下完这场雪
05-24 600
Scala 中模式匹配类似于 Java 中的 switch，但是更加强大 模式匹配语法中，采用match 关键字声明， 每个分支采用case 关键字声明 需要匹配时， 会从第一个case 分支开始，如果匹配成功，那么执行对应的逻辑代码。 如果匹配不成功，继续执行下一个分支继续进行判断， 如果所有case 都不匹配，则会执行case _ 分支，类似与Java 中的default 语句 match的细节和注意事项 1）如果所有case都不匹配，那么会执行case _ 分支，类似于Java中default语句 2
Scala-模式匹配
Markble
08-30 4668
目录 一、基本语法 二、模式守卫 三、 模式匹配类型 3.1 匹配常量 3.2 匹配类型 3.3 匹配数组 3.4 匹配列表 3.5 匹配元组 3.6 匹配对象及样例类 四、 变量声明中的模式匹配 五、 for表达式中的模式匹配 六、 偏函数中的模式匹配(了解) Scala中的模式匹配类似于Java中的switch语法 int i = 10 switch (i) { case 10 : System.out.println("10"); break; ...
Scala之模式匹配(Patterns Matching)
热门推荐
Laurence的技术博客
04-04 1万+
前言首先，我们要在一开始强调一件很重要的事：Scala的模式匹配发生在但绝不仅限于发生在match case语句块中，这是Scala模式匹配之所以重要且有用的一个关键因素！我们会在文章的后半部分详细地讨论这一点。模式匹配的种类在Scala中一共有如下几种类型的模式匹配： 通配符匹配（Wildcard Pattern Matching ） 常量匹配 （Constant Pattern Matching
scala模式匹配
a18792721831的博客
02-11 308
scala模式匹配1.匹配值2.守卫匹配3.类型匹配+变量4.类成员匹配5.匹配数组6.匹配列表7.匹配元组8.多选分支9.提取器 dit地址 https://github.com/a18792721831/studyScala.git 1.匹配值 模式匹配。匹配值 创建函数 使用 结果 2.守卫匹配 模式匹配中的守卫模式 3.类型匹配+变量 4.类成员匹配 5.匹配数组...
浅谈Scala模式匹配
08-18
Scala 模式匹配详解 Scala 模式匹配是 Scala 语言中的一种强大语言特性，它允许开发者通过模式匹配来处理不同的数据类型和值。模式匹配的基本语法是 `e match { case Pattern1 => do Something case Pattern2 if-...
大数据开发-Scala-类型检查与模式匹配详解
Hoult丶吴邪
12-20 259
0.前言 类型检查和类型转换在每个语言里面都有对应实现，比如Java中的instanceof 和 isInstance，当然Scala语言也有，但是相对于其他语言，Scala为了简化开发，产生了强大的模式匹配，其原理和Java中的switch-case很类似，但是其匹配能力更强，不仅仅可以匹配值，匹配类型，也可以进行类匹配，还可以进行前缀类匹配，而且在Spark源码中大量使用了模式匹配，另外的就是隐式转换，在另外一篇文章讲解，本文从类型检查和类型转换入手，引入Scala常见的几种模式匹配及其使用。 1.类型
Scala-简易详解文章
06-28
15. **模式匹配**：Scala的模式匹配允许解构复杂数据结构，匹配不同的情况。 16. **IO**：Scala提供了方便的I/O库，用于文件读写和网络通信。 17. **隐式转换（Implicit）**：隐式转换允许在没有显式转换的情况下...
Scala学习（八）模式匹配
qq_41816516的博客
11-08 630
文章目录模式匹配基本语法模式守卫模式匹配类型匹配常量匹配类型匹配数组匹配列表匹配元组匹配对象及样例类 模式匹配 基本语法 模式匹配语法中，采用 match 关键字声明，每个分支采用 case 关键字进行声明，当需要匹配时，会从第一个 case 分支开始，如果匹配成功，那么执行对应的逻辑代码，如果匹配不成功，继续执行下一个分支进行判断。如果所有 case 都不匹配，那么会执行 case _分支，类似于 Java 中 default 语句。 val x:Int = 2 val y:Str
Scala模式匹配
weixin_53898747的博客
04-03 852
模式匹配
Scala的模式匹配详解
weixin_49165958的博客
10-22 1404
模式匹配是Scala中非常有特色，非常强大的一种功能。模式匹配，其实类似于Java中的swich case语法，即对一个值进行条件判断，然后针对不同的条件，进行不同的处理。 但是Scala的模式匹配的功能比Java的swich case语法的功能要强大地多，Java的swich case语法只能对值进行匹配。但是Scala的模式匹配除了可以对值进行匹配之外，还可以对类型进行匹配、对Array和List的元素情况进行匹配、对case class进行匹配、甚至对有值或没值（Option）进行匹配。 而且对于Sp
scala 模式匹配
qq_34132046的博客
07-06 331
模式匹配 目录模式匹配一、 模式种类二、模式重叠三、密封类Option类型四、不仅仅match，模式到处都可用 一、 模式种类 1. 通配模式：_ 相当于java switch里的defualt，匹配所有没有匹配上的对象 。 通配模式还可以用于对象的参数中，表示不关心对象的参数是什么。 2. 常量模式：任何常量如数字，布尔，字符等，只匹配自己，同时val和单例对象也可以当作常量使用。 3. 变量模式：变量模式和通配模式一样，可以匹配任何对象，当变量模式会将变量绑定成匹配上的对象，你可以用这个变量对对象做进一
Scala - 模式匹配
最新发布
阿年的博客
07-21 619
Scala中的模式匹配、模式守卫、匹配常量、类型、数组、列表、元组、对象以及样例类
Scala语言规范详解
"Scala语言规范.pdf" Scala是一种多范式编程语言...此外，还有模式匹配、异常处理、包和模块、控制流语句、特质、并发编程等内容，构成了Scala强大的语言特性和灵活性。这份规范为学习和理解Scala提供了全面的指导。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

楚生辉

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值