Scala模式匹配的用法

最新推荐文章于 2023-04-03 17:40:45 发布

极度丶浚爱

最新推荐文章于 2023-04-03 17:40:45 发布

阅读量1k

点赞数 1

分类专栏： Scala

本文链接：https://blog.csdn.net/qq_43123615/article/details/104780394

版权

Scala 专栏收录该内容

24 篇文章 0 订阅

订阅专栏

1 switch

Scala 中的模式匹配类似于 Java 中的 switch 语法，但是更加强大。
模式匹配语法中，采用 match 关键字声明，每个分支采用 case 关键字进行声明，当需要匹配时，会从第一个 case 分支开始，如果匹配成功，那么执行对应的逻辑代码，如果匹配不成功，继续执行下一个分支进行判断。
如果所有 case 都不匹配，那么会执行case _ 分支，类似于 Java 中 default 语句。
如果没有任何模式匹配成功，那么会抛出 MatchError。

  def main(args: Array[String]): Unit = {
    val v = "/"
    v match{
      case "+" => println("++++++++++++")
      case "-" => println("------------")
    }
  }

Exception in thread "main" scala.MatchError: / (of class java.lang.String)
	at com.nefu.scala.chaptor08.Scala01_Match1$.main(Scala01_Match1.scala:11)
	at com.nefu.scala.chaptor08.Scala01_Match1.main(Scala01_Match1.scala)

每个 case 中，不用 break 语句。
可以在 match 中使用任何类型，而不仅仅是数字。
Jav的switch语句支持的类型：

byte short int char enum String

// Java
int i = 1;
switch ( i ) {
case 0 :
break;
case 1 :
break;
default :
break
}

下面是Scala：

变量 match {
	case _: 1	//默认可以放在最上面
	case ex:Exception => println(ex.getMessage)
	
}

异常处理中的模式匹配：

    try {
      val r = 10 / 0  //0不能作为除数
    } catch {
      case ex: ArithmeticException=> println("捕获了除数为零的算数异常")
      case ex: Exception => println("捕获了异常")
    } finally {
      // 无论有没有出现异常都要执行的代码
    }
  }

2 守卫

如果想要表达匹配某个范围的数据，就需要在模式匹配中增加条件守卫守卫条件更灵活增加了一个条件判断

  val v = "a"
    v match {
      case "+" => println("++++++++++++")
      case "-" => println("------------")
      case _ if(v.equals("a")) => println("aaaaaaaaaaaaa")
      case _ => println("Nothing...")
    }

3 模式中的变量

如果在 case 关键字后跟变量名，那么 match 前表达式的值会赋给那个变量。

    val v = "a"
    v match {
      case "+" => println("++++++++++++")
      case "-" => println("------------")
      case ch => println("length = " + ch.length)
      case _ if(v.equals("a")) => println("aaaaaaaaaaaaa")
      case _ => println("Nothing...")

4 类型匹配

可以匹配对象的任意类型，这样做避免了使用 isInstanceOf 和 asInstanceOf 方法。

    val a = 6
    val obj = if(a == 1) 1
    else if(a == 2) "2"
    else if(a == 3) BigInt(3)
    else if(a == 4) Map("aa" -> 1)
    else if(a == 5) Map(1 -> "aa")
    else if(a == 6) Array(1, 2, 3)
    else if(a == 7) Array("aa", 1)
    else if(a == 8) Array("aa")

    //在类型的模式匹配中不支持泛型 Map[String, Int]和Map[Int, String]一样
    val r1 = obj match {
      case x: Int => x  //类型匹配
      case s: String => s.toInt
      case _: BigInt => Int.MaxValue //这个下划线是变量名 ？？？
      case m: Map[String, Int] => "Map[String, Int]类型的 Map 集合"
      case m: Map[Int, String] => "Map[Int,String]类型的 Map 集合"
      case a: Array[String] => "It's an Array[String]"  //String[]
      case a: Array[Int] => "It's an Array[Int]"        //int[]
      case _ => 0
    }
    println(r1 + ", " + r1.getClass.getName

length = 1
It's an Array[Int], java.lang.String

注：类型不能直接匹配泛型类型（类型匹配不考虑泛型）数组的“泛型”其实是类型，所以生效。

5 匹配数组、列表、元组

Array(0) 匹配只有一个元素且为 0 的数组。
Array(x,y) 匹配数组有两个元素，并将两个元素赋值为 x 和 y。
Array(0,_*) 匹配数组以 0 开始。

5.1 匹配数组

    for (arr <- Array(Array(0), Array(1, 0), Array(0, 1, 0), Array(1, 1, 0), Array(1, 1, 0, 1))) {
      val result = arr match {
        case Array(0) => "0"
        case Array(x, y) => x + " " + y
        case Array(x, y, z) => x + " " + y + " " + z
        case Array(0, _*) => "0..."
        case _ => "something else"
      }
      println(result)

0
1 0
0 1 0
1 1 0
something else

5.2 匹配列表

与匹配数组相似，同样可以应用于列表



      for (list <- Array(List(0), List(1, 0), List(0, 0, 0), List(1, 0, 0))) {
        val result = list match {
          case 0 :: Nil => "0"
          case x :: y :: Nil => x + " " + y //（1， 0）
          case 0 :: tail => "0 ..." //list（0）上面已经满足了
          case _ => "something else"
        }
        println(result)
      }

0
1 0
0 ...
something else

5.3 匹配元组

同样可以应用于元组

    for (pair <- Array((0, 1), (1, 0), (1, 1))) {
      val result = pair match {
        case (0, _) => "0 ..."
        case (y, 0) => y + " 0"
        case _ => "neither is 0"
      }
      println(result)
    }

0 ...
1 0
neither is 0

6 对象匹配

对象匹配，什么才算是匹配呢？即， case 中对象的 unapply 方法返回 some 集合则为匹配成功，返回 none 集合则为匹配失败。

6.1 unapply

调用 unapply，传入 number
接收返回值并判断返回值是 None，还是 Some
如果是 Some，则将其中的值赋值给 n（就是 case Square(n)中的 n）
请参考伴生对象的 apply 方法理解

object Square {
  def unapply(z: Double): Option[Double] = {
    Some(math.sqrt(z))
  }
}




//unapply 提取器
  val number: Double = 36.0
  number match {
    case Square(n) => println(n)
    case _ => println("nothing matched")
  }

6.0

6.2 unapplySeq

调用 unapplySeq，传入 namesString
接收返回值并判断返回值是 None，还是 Some
如果是 Some，获取其中的值
判断得到的 sequence 中的元素的个数是否是三个
如果是三个，则把三个元素分别取出，赋值给 first， second 和 third

//创建 object Names：
object Names {
def unapplySeq(str: String): Option[Seq[String]] = {
if (str.contains(",")) Some(str.split(","))
else None
}
}
//模式匹配使用：
val namesString = "Alice,Bob,Thomas"
namesString match {
case Names(first, second, third) => {
println("the string contains three people's names")
println(s"$first $second $third") //s 表示后面的字符串中有表达式，要获取对应的值
}
case _ => println("nothing matched")
}

7 变量声明中的模式

match 中每一个 case 都可以单独提取出来，意思是一样的，如下：

    val (x, y) = (1, 2)
    val (q, r) = BigInt(10) /% 3
    val arr = Array(1, 7, 2, 9)
    val Array(first, second, _*) = arr
    println(first, second)

(1,7)

8 for 表达式中的模式

val map = Map("A"->1, "B"->0, "C"->3)
for ( (k, v) <- map ) {
println(k + " -> " + v)
}
for ((k, 0) <- map) {
println(k + " --> " + 0) // for 中匹配会自动忽略失败的匹配
}
for ((k, v) <- map if v == 0) {
println(k + " ---> " + 0)
}

9 样例类

样例类首先是类，除此之外它是为模式匹配而优化的类，样例类用 case 关键字进行声明：

9.1 样例类的创建

abstract class Amount
case class Dollar(value: Double) extends Amount
case class Currency(value: Double, unit: String) extends Amount
case object Nothing extends Amount

9.2 当我们有一个类型为 Amount 的对象时，我们可以用模式匹配来匹配他的类型，并将属性值绑定到变量：

for (amt <- Array(Dollar(1000.0), Currency(1000.0, "EUR"), Nothing)) {
val result = amt match {
case Dollar(v) => "$" + v
case Currency(_, u) => u
case Nothing => ""
}
println(amt + ": " + result)
}

当你声明样例类时，如下几件事情会自动发生：
- 构造器中的每一个参数都成为 val——除非它被显式地声明为 var（不建议这样做）
- 在伴生对象中提供 apply 方法让你不用 new 关键字就能构造出相应的对象，比如Dollar(29.95)或 Currency(29.95, "EUR")
- 提供 unapply 方法让模式匹配可以工作
- 将生成 toString、 equals、 hashCode 和 copy 方法——除非显式地给出这些方法的定义。除上述外，样例类和其他类型完全一样。你可以添加方法和字段，扩展它们。

10 case 语句的中置(缀)表达式

什么是中置表达式？ 1 + 2，这就是一个中置表达式。如果 unapply 方法产出一个元组，你可以在 case 语句中使用中置表示法。比如可以匹配一个 List 序列。

List(1, 7, 2, 9) match {
case first :: second :: rest => println(first + second + rest.length)
case _ => 0
}

11 匹配嵌套结构

操作原理类似于正则表达式
比如某一系列商品想捆绑打折出售

11.1 创建样例类

abstract class Item
case class Article(description: String, price: Double) extends Item
case class Bundle(description: String, discount: Double, item: Item*) extends Item
  def main(args: Array[String]): Unit = {
    val a = Article("aaa",1)
    println(a.description)
    println(a.price)
  }

aaa
1.0

11.2 匹配嵌套结构

val sale = Bundle("书籍", 10, Article("漫画", 40), Bundle("文学作品", 20, Article(" 《阳关》", 80), Article("《围城》 ", 30))

11.3 将 descr 绑定到第一个 Article 的描述

val result1 = sale match {
case Bundle(_, _, Article(descr, _), _*) => descr
}
println(result1)

11.4 通过@表示法将嵌套的值绑定到变量。 _*绑定剩余 Item 到 rest

val result2 = sale match {
case Bundle(_, _, art @ Article(_, _), rest @ _*) => (art, rest)
}
println(result2)

11.5 不使用_*绑定剩余 Item 到 rest

val result3 = sale match {
case Bundle(_, _, art @ Article(_, _), rest) => (art, rest)
}
println(result3)

12.6 计算某个 Item 价格的函数，并调用

def price(it: Item): Double = {
it match {
case Article(_, p) => p
case Bundle(_, disc, its@_*) => its.map(price _).sum - disc
}
}
println(SwitchBaseSyllabus.price(sale))

12 封闭类

如果想让 case 类的所有子类都必须在申明该类的相同的源文件中定义，可以将样例类的通用超类声明为 sealed，这个超类称之为密封类，密封就是不能在其他文件中定义子类。

abstract sealed class Item
//样例类 样本类
case class Article(description: String, price: Double) extends Item{}
case class Bundle(description: String, discount: Double, item: Item*) extends Item
case object MyNothing extends Item

13 模拟枚举

样例类可以模拟出枚举类型

13.1 创建样例类

abstract class TrafficLightColor
case object Red extends TrafficLightColor
case object Yellow extends TrafficLightColor
case object Green extends TrafficLightColor

13.2 模拟枚举

for (color <- Array(Red, Yellow, Green))
println(
color match {
case Red => "stop"
case Yellow => "slowly"
case Green => "go"
})

14 偏函数

将集合中的数字加 1 并返回新的集合

    val list = List(1, 2, 3, 4)
    def add( obj : Any ) : Int = {
      obj match {
        case i:Int => i+1
      }
    }
    val list1 = list.map( add )
    println(list1)

List(2, 3, 4, 5)

如果这个时候，集合的元素有字符串，会出现什么情况？

val list = List(1, 2, 3, 4, "ABC")
def add( obj : Any ) : Int = {
obj match {
case i:Int => i+1
}
}
val list1 = list.map( add )
println(list1)
// 此时程序执行时会发生错误 matcherror

在对符合某个条件，而不是所有情况进行逻辑操作时，使用偏函数是一个不错的选择
将包在大括号内的一组 case 语句封装为函数，我们称之为偏函数，它只对会作用于指定类型的参数或指定范围值的参数实施计算，超出范围的值会忽略（未必会忽略，这取决于你打算怎样处理）
偏函数在 Scala 中是一个特质 PartialFunction

val list = List(1, 2, 3, "abcd")
    // 定义一个将 List 集合里面数字加 1 的偏函数
    // 构建特质的实现类
    // [Any, Int]是泛型，第一个表示参数类型，第二个表示返回参数
    val addOne= new PartialFunction[Any, Int] {
      def apply(any: Any) = any.asInstanceOf[Int] + 1
      def isDefinedAt(any: Any) = if (any.isInstanceOf[Int]) true else false
    }
    //val list1 = list.map( addOne ) // // (X) map 函数不支持偏函数
    val list1 = list.collect(addOne)// OK collect 函数支持偏函数
    println(list1)

List(2, 3, 4)

声明偏函数，需要重新特质中的方法，有的时候会略显麻烦，而 Scala 其实提供了简单的方法

 def f2: PartialFunction[Any, Int] = {
      case i: Int => i + 1 // case 语句可以自动转换为偏函数
    }

 val list1 = list.collect{case i:Int => i + 1}// OK collect 函数支持偏函数