Scala学习——match，case 模式匹配

package com.dtspark.scala.basics


//case class 是一个模式类，而case object 是全局的一个唯一的实例，

//模式类之间不能互相继承，必须统一继承一个抽象类或者trait
class DataFrameWork
//模式类，与普通类没什么区别，只是一定要有参数
case class ComputationFramework(name:String,popular:Boolean)extends DataFrameWork
case class StorageFramework(name:String,popular:Boolean)extends DataFrameWork

object helloPatternMatch {
  def main(args: Array[String]): Unit = {
    getSalary("dddd",6)
    getMatchType(6.0)
    
    getMatchCollection(Array("Scala","hadoop"))
    
    getBigDataType(ComputationFramework("Spark",true))
    
    
    val _map = Map("Spark"->"hot","hadoop"->"half_hot")
    getValue("Spark",_map)
  }
  
  def getSalary(name:String,age:Int){
    name match{
      //从前往后匹配
      case "Spark"=>println("$150000/year")
      case "Hadoop"=>println("$100000/year")
      //加入判断条件(用变量接受参数)
      case _name if age>=5 =>println(name+":"+age+" $140000/year")
      case _  =>println("$90000/year")//都不匹配时
    }
  }
  //对类型进行匹配
  def getMatchType(msg:Any){
    msg match{
      case i : Int=>println("Integer")
      case s : String=>println("String")
      case d : Double=>println("Double")
      case _=>println("Unknow type")
    }
  }
  //对数组的匹配
   def getMatchCollection(msg:Array[String]){
    msg match{

      case Array("Scala")=>println("one element")
      case Array("Scala","Java")=>println("two element")
      //以Scala开头的数组(可有多个成员)
      case Array("Scala",_*)=>println("many element begin from scala")
      case _=>println("Unknow type")
    }
  }
   //对类的匹配
   def getBigDataType(data:DataFrameWork){
     data match{
       case ComputationFramework(name,popular)=>
         println("computationFramework  "+"name:"+name+" popular:"+popular)
       case StorageFramework(name,popular)=>
         println("StorageFramework  "+"name:"+name+" popular:"+popular)
       case _ =>println("Some other type")
         
     }
   }
   /**
    * 对map的匹配
    * 特别注意some和none的使用
    */
   def getValue(key:String,content:Map[String,String]){
     content.get(key) match{
       case Some(value)=>println(value)
       case None=>println("No found!!")
     }
   }
   
}

 

添加内容1：对传入参数个数的匹配。
其中第二个case表达的是如果这个数组传入的是三个参数，则将第一个赋给scala，第二个赋给spark，第三个赋给flink，这三个都是变量名，然后在对这三个变量进行一些操作

命令行代码：

scala> def data(array:Array[String]){
        array match{
               case Array("Scala")=>println("scala")
               case Array(scala,spark,flink) if(scala=="Spark")=>println(scala+" : "+spark+" : "+flink)
               case Array("Spark",_*)=>println("spark ....")
               case _ =>println("others")
       }
    }
data: (array: Array[String])Unit

输出：

scala> data(Array("Spark is good~!"))
others

scala> data(Array("Spark","ssd"))
spark ....

scala> data(Array("Spark","scala","flink"))
Spark : scala : flink

scala> data(Array("Spk","scala","flink"))
others

添加内容2：case class的一些性质

1.定义为case class 的类在实例化时，可以不使用new 关键字。

case  class  People（name:String, age:Int）

  val p = People( "zs" , 30)

2. 定义为case class 的类 默认实现了 equals 和hashcode 方法

3. 默认是可序列化的

4. 其构造函数的参数 是public 访问的。如  p.name

5.支持模式匹配

 

命令行代码：

scala> case class PhoneExt(name: String, ext: Int)
defined class PhoneExt

scala> val extensions = List(PhoneExt("steve", 100), PhoneExt("robey", 200))
extensions: List[PhoneExt] = List(PhoneExt(steve,100), PhoneExt(robey,200))

scala> extensions.filter { case PhoneExt(name, extension) => extension < 200 }
res0: List[PhoneExt] = List(PhoneExt(steve,100))