Scala（第八章 模式匹配）

已于 2023-08-11 23:43:38 修改
阅读量168 收藏
点赞数
分类专栏： scala 文章标签： scala python 开发语言
于 2023-08-10 09:17:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nlcexiyue/article/details/132201982
版权

文章目录

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

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;
}

   
   

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

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

8.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
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

1）说明

1、如果所有case都不匹配，那么会执行case_分支，类似于Java中default语句，若此时没有case_分支，那么会抛出MatchError。
2、每个case中，不需要使用break语句，自动中断case。
3、match case语句可以匹配任何类型，而不只是字面量
4、=> 后面的代码块，直到下一个case语句之前的代码是作为一个整体执行，可以使用{}括起来，也可以不括。

8.2 模式守卫

1）说明

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

2）案例实操

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))
 }
}

   
   

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

8.3 模式匹配类型

8.3.1 匹配常量

1）说明

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

2）实操

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 +"
 }
}

   
   

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

8.3.2 匹配类型

1）说明

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

2）案例实操

object TestMatchClass {
 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")))
 }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

8.3.3 匹配数组

1）说明

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

2）案例实操

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 _ => "something else"
 }
 println("result = " + result)
 }
 }
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

8.3.4 匹配列表

1）方式一

object TestMatchList {
 def main(args: Array[String]): Unit = {
 //list 是一个存放 List 集合的数组
 //请思考，如果要匹配 List(88) 这样的只含有一个元素的列表,并原值返回.应该怎么写
 for (list <- Array(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)
 }
 }
}

 
 

 
 

  
  
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

2）方式二

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

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

8.3.5 匹配元组

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

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

扩展案例

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

 
 

 
 

  
  
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36

8.3.6 匹配对象及样例类

1）基本语法

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)
 }
}

 
 

 
 

  
  
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

小结：
1、val user = User(“zhangsan”,11)，该语句在执行时，实际调用的是 User 伴生对象中的apply 方法，因此不用 new 关键字就能构造出相应的对象。
2、当将 User(“zhangsan”, 11)写在 case 后时[case User(“zhangsan”, 11) => “yes”]，会默
认调用 unapply 方法(对象提取器)，user 作为 unapply 方法的参数，unapply 方法将 user 对象的 name 和 age 属性提取出来，与 User(“zhangsan”, 11)中的属性值进行匹配
3、case 中对象的 unapply 方法(提取器)返回 Some，且所有属性均一致，才算匹配成功,属性不一致，或返回 None，则匹配失败。
4、若只提取对象的一个属性，则提取器为 unapply(obj:Obj):Option[T]
若提取对象的多个属性，则提取器为 unapply(obj:Obj):Option[(T1,T2,T3…)]
若提取对象的可变个属性，则提取器为 unapplySeq(obj:Obj):Option[Seq[T]】

2）样例类

1、语法：
case class Person (name: String, age: Int)
2、说明：
2.1：样例类仍然是类，和普通类相比，只是其自动生成了伴生对象，并且伴生对象中自动提供了一些常用的方法，如 apply、unapply、toString、equals、hashCode 和 copy。
2.2：样例类是为模式匹配而优化的类，因为其默认提供了 unapply 方法，因此，样例类可以直接使用模式匹配，而无需自己实现 unapply 方法。
2.3：构造器中的每一个参数都成为 val，除非它被显式地声明为 var（不建议这样做）
3、实操
上述匹配对象的案例使用样例会节省大量代码
在这里插入图片描述

8.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")
 }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

8.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
 }
 }
}

 
 

 
 

  
  
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

8.6 偏函数中的模式匹配（了解）

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

1）偏函数定义

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

在这里插入图片描述

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

2）偏函数原理

上述代码会被 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)
 }
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

3）偏函数使用

1、偏函数不能像 second(List(1,2,3))这样直接使用，因为这样会直接调用 apply 方法，而应该调用 applyOrElse 方法，如下
second.applyOrElse(List(1,2,3), (_: List[Int]) => None)
2、applyOrElse 方法的逻辑为 if (ifDefinedAt(list)) apply(list) else default。如果输入参数满足条件，即 isDefinedAt 返回 true，则执行 apply 方法，否则执行 defalut 方法，default 方法为参数不满足要求的处理逻辑。

4）案例实操
4.1 需求

将该 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
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

4.2 实操

方法一：
List(1,2,3,4,5,6,"test").filter(_.isInstanceOf[Int]).map(_.asInstanceOf[Int] + 1).foreach(println)
方法二：
List(1, 2, 3, 4, 5, 6, "test").collect { case x: Int => x + 1 }.foreach(println)

 
 

 
 
  • 1
  • 2
  • 3
  • 4

下一章（第九章） 异常

某科学的南条
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第十二章 Scala进阶——模式匹配
qq_34291505的博客
02-12 6861
前一章提到过，Scala的内建控制结构里有一个match表达式，用于模式匹配或偏函数。模式匹配是Scala中一个强大的高级功能，并且在Chisel中被用于硬件的参数化配置，可以快速地裁剪、配置不同规模的硬件电路。所以，尽管模式匹配不是很容易就能掌握并熟练运用，但是学会它将会对软、硬件编程都大有帮助。 一、样例类与样例对象 定义类时，若在最前面加上关键字“case”，那么这个类就被称为样例类。S...
Scala--模式匹配
别下完这场雪
05-24 588
Scala 中模式匹配类似于 Java 中的 switch，但是更加强大 模式匹配语法中，采用match 关键字声明， 每个分支采用case 关键字声明 需要匹配时， 会从第一个case 分支开始，如果匹配成功，那么执行对应的逻辑代码。 如果匹配不成功，继续执行下一个分支继续进行判断， 如果所有case 都不匹配，则会执行case _ 分支，类似与Java 中的default 语句 match的细节和注意事项 1）如果所有case都不匹配，那么会执行case _ 分支，类似于Java中default语句 2
Scala - 模式匹配
阿年的博客
07-21 607
Scala中的模式匹配、模式守卫、匹配常量、类型、数组、列表、元组、对象以及样例类
Scala 模式匹配详解
hyunbar的博客
12-30 2354
大数据技术AI Flink/Spark/Hadoop/数仓，数据分析、面试，源码解读等干货学习资料 101篇原创内容 ...
快学scala第一章习题答案.doc
12-24
Scala 语言支持模式匹配，模式匹配是一种高级的控制结构，可以用来处理复杂的数据结构。 十一、Scala 中的类型系统 Scala 语言具有一个强大的类型系统，支持多种类型系统概念，如参数多态、协变和逆变等。Scala ...
scala程序设计第三版
05-23
2. **模式匹配**：Scala提供了强大的模式匹配功能，它允许开发者根据值的不同形态执行不同的操作。这在处理数据结构（如case类和枚举）和解析数据时特别有用。 3. **集合框架**：Scala的集合库是其强大功能的核心...
Scala.pdf中文高清第二版
01-16
7. **模式匹配**：Scala的模式匹配功能强大，不仅可以用于解构数据结构，还可以用于解析和处理XML，甚至进行异常处理。 8. **FP与OOP的结合**：Scala巧妙地将面向对象和函数式编程融合在一起，使得开发者可以根据...
scala-2.13.8 解压安装版
09-14
- **模式匹配**：通过模式匹配，可以对数据结构进行解构并根据不同的情况执行不同的操作。 - **案例类**：简化了模式匹配，它们自动提供unapply方法，用于匹配。 - **Actor模型**：Scala内建对Akka Actor的支持，...
programming in scala（第三版）
06-02
2. **模式匹配**：Scala的模式匹配功能强大，可以用于解构数据结构，实现决策逻辑，甚至处理异常。 3. **高阶函数**：函数在Scala中是第一类公民，可以作为参数传递，也可以作为返回值。这使得函数式编程风格在...
Spark2.x 入门：Apache Kafka 作为 DStream 数据源
跟着大数据和AI去旅行
08-23 213
注意，上面命令中，"master:9092 wordsender 3 5"是提供给KafkaWordProducer程序的4个输入参数，第1个参数master:9092是Kafka的broker的地址，第2个参数wordsender是topic的名称，我们在KafkaWordCount.scala代码中已经把topic名称写死掉，所以，KafkaWordCount程序只能接收名称为"wordsender"的topic。这个终端窗口就放在这里，不要关闭，千万不要关闭，就让它一直不断发送单词。
如何在Python中使用IP代理
最新发布
IPIPGO的博客
08-23 326
通过以上步骤，你应该已经学会了如何在Python中使用IP代理。无论是单个代理IP、带认证的代理IP，还是批量使用代理IP，这些方法都能帮助你在实际项目中灵活应用。希望这篇文章对你有所帮助，如果你有任何问题或建议，欢迎在评论区留言，我们会尽力为你解答。t=N7T8。
常见面试问题(Python)
jiao_mrswang的博客
08-23 104
5、GIL全局解释锁。
零基础学习人工智能—Python—Pytorch学习（六）
kiba518的博客
08-21 838
前言 本文主要讲神经网络的上半部分。 这篇文章开始有很多公式了，这些公式都很简单，但是如果是不经常在脑海里思考公式的人，那可能需要多花点时间做一下自我训练，个人感觉，也就几天时间，就能把自己感觉给调整出来。 习惯了公式看下面内容就会轻松很多，另外如果要深入学习人工智能，熟练的认知公式也是个必须的事情。 另外，我发现我前面文章写的有歧义的地方还是挺多，虽然，已经改了一部分，但，可能还有没发现的，大...
2024.8.20 Python，链表，二叉树
RaidenMessi的博客
08-20 408
代码逻辑：第一层，对l1.val进行判断，谁小听谁的，目标是输出这个链表，那就要修改这个链表，在第一层的时候，是先进函数，再赋值，所以在第一层的时候还没进行赋值就已经进第二层了，在第二层的时候还没赋值就又进第三层了，以此类推，然后每一次都抛掉一个最小的数。可能之后就理解了吧。我想了下，我决定不管了，就跟二分法当时一样，我直接按逻辑走，谁小谁就去用他的next继续和他刚才的人比，同时输出他自己本身，完事了。链表是线性表，是一维的，保存了现在这个数的值和下一个数的地址，分为表元素域，下一结点链接域，
基于Python星载气溶胶数据处理与反演分析
lwjnlqiqi的博客
08-21 1147
Python星载气溶胶数据处理与反演分析
基于YOLO V8的PCB缺陷检测识别系统（python源码+Pyqt5界面+数据集+训练代码）
2401_83580557的博客
08-22 408
基于YOLO V8的PCB缺陷检测识别系统【python源码+Pyqt5界面+数据集+训练代码】
Transformer经典模型实战：零基础训练一个面向中文的T5模型（Text to Text Transfer Transformer）
bayesian1的博客
08-20 1075
Transformer经典模型实战：零基础训练一个面向中文的T5模型（Text to Text Transfer Transformer），通过构建T5模型，采用中文重写任务的数据集进行训练，模型效果非常好，貌似还涌现出了一定的创造力。
python之matplotlib （5 散点图和柱状图）
这是C.L 的博客，欢迎大家学习浏览！！
08-20 460
附：colormap对照 '%.f'%y‘是标注数据的形式设置：保留两位小数，数据来源于y数组。也可以这样写：f'{y:.2f}',在它前面的参数是标注的位置。也可以是一个数组，表示每个点的颜色不同。ax.bar()中y参数是直方图的高度，其中facecolor是条形图的颜色，而edgecolor是除了条形图内的颜色。也可以是一个数组，表示每个点的大小不同。参数来指定一个colormap，用于映射颜色数组到颜色。
Scala编程指南前15章翻译详解
14. **样本类和模式匹配**：第15章讲解了Scala的模式匹配机制，以及如何使用样例类来简化对象实例化和解构。 这些章节提供了对Scala全面而深入的理解，适合已经有一定编程经验并希望学习或进一步掌握Scala的开发者...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值