Scala之模式匹配

深碍√TFBOYSˉ_ 2022-12-29 01:47 182阅读 0赞

# Scala之模式匹配 #

### 目录 ###

*  Scala之模式匹配
 *   *  一、概述
     *  二、基本语法
     *  三、模式守卫
     *  四、模式匹配类型
     *   *  4.1 匹配常量
         *  4.2 匹配类型
         *  4.3 匹配数组
         *  4.4 匹配列表
         *  4.5 匹配元组
         *  4.6 匹配对象及样例类
     *  五、变量声明中的模式匹配
     *  六、for表达式中的模式匹配
     *  七、偏函数中的模式匹配

## 一、概述 ##

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

## 二、基本语法 ##

package com.scala.charpter08
    
    import scala.io.StdIn
    
    object $01_MathDefine { 
      
      /** * 模式匹配语法： * 变量 match{ * case 条件1 => { * .... * } * case 条件1 => { * .... * } * ..... * } * * 模式匹配有返回值，返回值为符合条件的分支的{}中最后一个表达式的结果值 * @param args */
      def main(args: Array[String]): Unit = { 
        
        val  word = StdIn.readLine("请输入一个单词")
        
        val result = word match { 
          case  "hadoop" =>
            println("单词是hadoop")
            println("...........")
            10
          case  "spark" =>
            println("单词是spark")
            println("...........")
            20
          case x=>
            println(s"单词是${x}")   
        }
        
        println(result) 
    
      } 
    }

**说明**

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

## 三、模式守卫 ##

package com.scala.charpter08
    
    import scala.io.StdIn
    
    object $02_MathIf { 
      
      /** * 模式匹配守卫： * 变量 match { * case 条件1 if (布尔表达式) =>{ * ..... * } * case 条件1 if (布尔表达式) =>{ * ..... * } * ..... * } * @param args */
      def main(args: Array[String]): Unit = { 
      
        val line = StdIn.readLine("请输入一个单词：")
      
        line match { 
          case x if(x.contains("hadoop"))=>
            println("单词是hadoop")
          case x if(x.contains("spark"))=>
            println("单词是spark")
          case _=>
            println("其他。。。")     
        }
       
      }
    }

**说明**

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

## 四、模式匹配类型 ##

### 4.1 匹配常量 ###

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

**说明**

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

### 4.2 匹配类型 ###

package com.scala.charpter08
    
    import scala.util.Random
    
    object $03_MatchType { 
      
      def main(args: Array[String]): Unit = { 
        
        val list: List[Any] = List(2,9.0,false,"hello")
        
        val index: Int = Random.nextInt(list.length)
        
        val parm = list(index)
        println(parm)
        
        parm match { 
          case _:String=>
            println("string.....")
          case _:Int=>
            println("Int......")
          case _:Double=>
            println("double....")
          case _=>
            println("其他。。。")    
        }
       
      } 
    }

**说明**

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

### 4.3 匹配数组 ###

package com.scala.charpter08
    
    object $04_MatchArray { 
      
      def main(args: Array[String]): Unit = { 
        
        val arr:Array[Any] = Array(78)
        
        arr match { 
          
          //匹配数组只有一个元素的情况
          case Array(x)=>
            println(s"数组只有一个元素${x}")
          
          //匹配数组有四个元素的情况，类型为。。。
          case Array(x:Int,y:Double,a,z:String)=>
            println(s"数组有四个元素，类型分别为。。。。。。${x}")
          
          //匹配数组有四个元素
          case Array(x,y,a,z)=>
            println(s"数组有四个元素，类型分别为。。。。。。${x}")
          
          //匹配数组至少有一个元素
          case Array(x,_*)=>
            println("数组至少有一个元素。。。")
         
          //其他情况
          case _=>
            println("其他。。。")   
        }
        
      } 
    }

**说明**

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

### 4.4 匹配列表 ###

package com.scala.charpter08
    
    object $05_MatchList { 
      
      def main(args: Array[String]): Unit = { 
      
        val list: List[Any] = List(1,8.0,false,"scala",11)
        
       	 //与Array类似进行匹配
         list match { 
          
    	      //匹配列表只有一个元素的情况
    	      case List(x)=>
    	        println(s"数组只有一个元素${x}") 
    	      //匹配列表有四个元素的情况，类型为。。。
    	      case List(x:Int,y:Double,a,z:String)=>
    	        println(s"数组有四个元素，类型分别为。。。。。。${x}")
    	      //匹配列表有四个元素
    	      case List(x,y,a,z)=>
    	        println(s"数组有四个元素，类型分别为。。。。。。${x}")
    	      //匹配列表至少有一个元素
    	      case List(x,_*)=>
    	        println("数组至少有一个元素。。。")   
    	      //其他情况
    	      case _=>
    	        println("其他。。。")
            
        }
          
        
        list match { 
      
    	      case x::Nil=>
    	        println("列表只有一个元素")
    	      case (x:String)::y::(z:Int)::a::Nil=>
    	        println("列表有四个元素，类型分别为。。。。")
    	      case x::y::z::a::Nil=>
    	        println("列表有四个元素")
    	      case x::tail=>
    	        println(s"列表至少有一个元素${x} ${tail}")
    	      case _=>
    	        println("其他")
        }
         
        
        val list2:List[Any] = List(1,2,3,4)
        //泛型擦除，集合的泛型主要用来在代码编写期间规定集合中数据元素的类型
        //泛型在编译的时候会被擦掉，任何list都能匹配上
        list match { 
          case x:List[Boolean]=>
            println("boolean....")
          case x:List[String]=>
            println("string.....")
          case x:List[Int]=>
            println("int........")
          case x:List[Any]=>
            println("any....")
          case _=>
            println("........")      
        }
       
      }
    }

### 4.5 匹配元组 ###

package com.scala.charpter08
    
    object $06_MatchTope { 
      
      def main(args: Array[String]): Unit = { 
        
        val t1:(Any,Any,Any)=("zhangsna","20","shezhen")
        
        t1 match { 
          case (x:String,y:Int,z:String)=>
            println("...........")
          case (_,_,_)=>
            println("元素个数是3个")
          case _=>
            println("其他")
        }
      
      
        val list = List(
          ("宝安",("宝安中学",("大神班",("zhangsan",20)))) ,
          ("宝安",("宝安中学",("大神班",("lisi",20)))),
          ("宝安",("宝安中学",("大神班",("wangwu",20)))),
          ("宝安",("宝安中学",("大神班",("zhaoliu",20))))
        )
        
        list.map(x=>{ 
          x match { 
            case (region,(school, (className,(stuName,age))))=>
            stuName
          }
        }).foreach(println)
     
      } 
    }

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

package com.scala.charpter08
    
    object $07_MatchClass { 
      
      case class Person(val name:String,var age:Int,addr: String)
      
      class Student(val name:String,var age:Int,val addr:String)
      
      object Student{ 
      
        def apply(name: String, age: Int, addr: String): Student = new Student(name, age, addr)
      
        def unapply(stu: Student): Option[(String, Int, String)] = { 
          if(stu==null)
            None
          else
            Some((stu.name,stu.age,stu.addr))      
          
        }
      
      }
      
      
      abstract class Sex
      
      case object Man extends Sex
      
      case object Woman extends Sex
      
      def xx(sex:Sex)={ 
        println(sex)
      }
      
      /** * 样例类： * 语法：case class 类名([var/val] 属性名:类型,....) * 创建样例类对象：类名(属性值,....) * 属性不用var/val修饰时默认就是val * 样例类其实就是伴生对象和伴生类的简写 * * 样例对象： * 语法：case object object名称 * 一般用于枚举 * * * 普通类不能直接用于模式匹配，要想用于模式匹配需要在伴生对象中添加unapply方法 * * @param args */
      def main(args: Array[String]): Unit = { 
      
        val person = Person("zhangsan",20,"shenzhen")
        println(person.name)
        println(person.addr)
        println(person.age)
        
        person.age=90
        println(person.age)
      
    // person.addr = "kkk"
      
        val lisi: Student = Student("lisi",9,"shanghai")
        lisi.age=990
        println(lisi.name)
        println(lisi.age)
      
      
        xx(Man)
      
      
        person match { 
          case Person(x,y,z)=>
            println(x,y,z)
            
        }
       
        val sudent = new Student("wangwu",44,"ilovyou")
        
        sudent match { 
          case Student(x,y,z)=>
            println(x,y,z)
        } 
        
      } 
    }

## 五、变量声明中的模式匹配 ##

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

## 六、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
        }
      }
    }

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

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

**1）偏函数定义**

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

注：该偏函数的功能是返回输入的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)
        }
      }

**3）偏函数使用**

偏函数不能像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方法为参数不满足要求的处理逻辑。

**4）案例实操**  
（1）需求

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

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