Scala 模式匹配

一、模式匹配

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

1、基本语法

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

2、语法说明

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

3、案例示例

package Scala04_moshipipei
//模式匹配基本语法
class test01_moshi {

}
object test01_moshi{
  def main(args: Array[String]): Unit = {
    //1、基本语法定义
    val x:Int = 10
    val y:String = x match {
      case 1 => "one" //如果为1那么返回的是one，中间是=> 连接
      case 2 => "two"
      case 3 => "there"
      case _ => "这就是默认情况了，0"
    }//判断x等于什么，如果x为1那么y就是one，如果x为2那么y就是two
    println(y)

    //2、示例；用模式匹配实现简单的二元运算
    val a = 25
    val b = 13
    def hanshu(op:Char) = op match {
      case '+' => a + b
      case '-' => a - b
      case '*' => a * b
      case '/' => a / b
      case '%' => a % b
      case _ => "非法运算符"

    }
    println(hanshu('*'))
    println(hanshu('+'))
    println("\\") //传一个字符进去，还要进行转义


  }
}

二、模式守卫

如果想要表达匹配某个范围的数据，就需要在模式匹配中增加条件守卫
注意：num 就是那个 i，然后调用的时候传入参数进去就可以了

// 模式守卫
    //求一个整数的绝对值
    def fanfga(num:Int) = num match { //num就是下面的那个i
      case i if i >= 0 => i //定义一个i,如果i大于等于0就返回i
      case i if i < 0 => -i //如果小于0 那么输出-i，那肯定就是绝对值

    }
    println(fanfga(5))
    println(fanfga(0))
    println(fanfga(-5))

在这里插入图片描述

三、模式匹配类型

Scala 中，模式匹配可以匹配所有的字面量，包括字符串，字符，数字，布尔值等等。
推荐还是把 case _ 加上，因为写的条件可能就那么几个，要是写错了，就会报 MatchError

1、匹配常量

 //Scala 中，模式匹配可以匹配所有的字面量，包括字符串，字符，数字，布尔值等等。
    //1、匹配常量
    def hanshu(x:Any):String = x match { //返回值不一定非得String，其他的也可以
      case 1 => "num one" //这就是返回值
      case "hello scala" => "String hello"
      case true => "Boolen true" //连布尔类型都可以
      case '+' => "Char +"
      case _ => ""  //建议还是要设置一个这个，然后条件是有限的，传入参数要是没有就报错了
    }
    println(hanshu(1))
    println(hanshu("hello scala"))
    println(hanshu(true))
    println(hanshu(0.3))

在这里插入图片描述

2、匹配类型

Scala 不仅仅可以匹配常量，还可以匹配数据结构，比如列表，数组.
注意：类型匹配的时候要注意，比如定义了List[String]泛型，规定的定义的是String类型的，但是Int类型的还是匹配上了，因为Scala 的底层有泛型擦除，他只会匹配到是一个list，泛型会自动擦除。而数组比较特殊，它是没有泛型擦除的，所以特别注意这两个地方，容易出现Bug

package Scala04_moshipipei
//模式匹配类型
class test02_pipeileixing {

}
object test02_pipeileixing{
  def main(args: Array[String]): Unit = {
    //Scala 中，模式匹配可以匹配所有的字面量，包括字符串，字符，数字，布尔值等等。
    //1、匹配常量
    def hanshu(x:Any):String = x match { //返回值不一定非得String，其他的也可以
      case 1 => "num one" //这就是返回值
      case "hello scala" => "String hello"
      case true => "Boolen true" //连布尔类型都可以
      case '+' => "Char +"
      case _ => ""  //建议还是要设置一个这个，然后条件是有限的，传入参数要是没有就报错了
    }
    println(hanshu(1))
    println(hanshu("hello scala"))
    println(hanshu(true))
    println(hanshu(0.3))

    println("================")
    //2、匹配类型
    def hanshu2(x:Any):String = x match {
      case i:Int => "int" + i //相当于前面规定了这个变量必须的是Int类型的才能匹配上
      case i:String => "String," + i
      case list: List[String] => "list:" + list //连List类型都可以定义
      case array:Array[Int] => "现在是第"+array.mkString(",")+"圈" //因为数组直接输出是引用，所以要用mkString方法输出
      case a => "Something else:" + a //这是兜底的方法，要拿到值的话就不能用 _ ，必要要设置一个变量
    }
    println(hanshu2(35))
    println(hanshu2("hello"))
    println(hanshu2(List("hi","hello")))
    println(hanshu2(List(2,23)))
    println(hanshu2(Array("hi","hello")))
    println(hanshu2(Array(2,23)))
  }
}

在这里插入图片描述

3、匹配数组

Scala 模式匹配，匹配数组非常强大，可以进行各种模糊的匹配，比如可以匹配必须是三个元素，或者中为1的三个元素的数组。

   //3、匹配数组
    for (arr <- List(
      Array(0),
      Array(1,0),
      Array(0,1,0),
      Array(1,1,0),
      Array(2,3,7,15),
      Array("hello",20,30)
    )){
     val result = arr match {
       case Array(0) => "0"
       case Array(1,0) => "1,0"
       case Array(x,y) => "Array:" + x + y //相当于可以进行模糊查询，匹配两元素数组
       case Array(0,_*) => "以0开头的数组"
       case Array(x,1,z) => "中间为1的三元素数组"
       case _ => "兜底的方法"
     }
      println(result)
    }