模式匹配（二十）

简介

  Scala 提供了强大的模式匹配机制，应用非常广泛。一个模式匹配包含了一系列备选项，每个都开始于关键字 case。每个备选项都包含了一个模式及一到多个表达式。箭头符号 => 隔开了模式和表达式。

模式匹配入门

简单实例

object PatternMatching extends App{
  for(i<- 1 to 100){
    i  match {
      case 10 => println(10)
      case 50 => println(50)
      case 80 => println(80)
      case _ => 
    }
  }
}

更为灵活的匹配方式

object PatternMatching extends App{
  for(i<- 1 to 100){
    i  match {
      case 10 => println(10)
      case 50 => println(50)
      case 80 => println(80)
      //增加守卫条件
      case _ if(i%4==0)=> println(i+":能被4整除")
      case _ if(i%3==0)=> println(i+":能被3整除")
      case _ =>
    }
  }
}

模式类型

常量模式

object ConstantPattern{
  def main(args: Array[String]): Unit = {
    //注意，下面定义的是一个函数
    //函数的返回值利用的是模式匹配后的结果作为其返回值
    //还需要注意的是函数定义在main方法中
    //也即scala语言可以在一个函数中定义另外一个函数
    def patternShow(x:Any)=x match {
      case 5 => "five"
      case true=>"true"
      case "test"=>"String"
      case null=>"null"
      case Nil=>"empty list"
      case _  =>"Other constant"
    }    
    println(patternShow(5))
  }
}

变量模式

object VariablePattern{
  def main(args: Array[String]): Unit = {
    def patternShow(x:Any)=x match {
      case 5 => "five"
      //所有不是值为5的都会匹配变量y
      //例如"xxx"，则函数的返回结果就是"xxx"
      case y => y
    }   
    println(patternShow("xxx"))
  }
}

构造器模式

//构造器模式必须将类定义为case class
case class Person(name:String,age:Int)
object ConstructorPattern {
  def main(args: Array[String]): Unit = {
      val p=new Person("摇摆少年梦",27)
      def constructorPattern(p:Person)=p match {
        case Person(name,age) => "Person"
        case _ => "Other"
      }
  }
}

序列模式

  序列模式指的是像Array、List这样的序列集合进行模式匹配。

object SequencePattern {
  def main(args: Array[String]): Unit = {
      val p=List("spark","hive","SparkSQL")
      def sequencePattern(p:List[String])=p match {
        //只需要匹配第二个元素
        case List(_,second,_*) => second
        case _ => "Other"
      }
      println(sequencePattern(p))
  }
}

元组模式

//匹配某个元组内容
object TuplePattern {
  def main(args: Array[String]): Unit = {
      val t=("spark","hive","SparkSQL")
      def tuplePattern(t:Any)=t match {
        case (one,_,_) => one
        case _ => "Other"
      }
      println(tuplePattern(t))
  }
}

类型模式

//匹配传入参数的类型
object TypePattern {
  def main(args: Array[String]): Unit = {

      def tuplePattern(t:Any)=t match {
        case t:String=> "String"
        case t:Int => "Integer"
        case t:Double=>"Double"
      }
      println(tuplePattern(5.0))
  }
}

变量绑定模式

object VariableBindingPattern {
  def main(args: Array[String]): Unit = {
       var t=List(List(1,2,3),List(2,3,4))      
       def variableBindingPattern(t:Any)= t match {
         //变量绑定，采用变量名（这里是e)
         //与@符号，如果后面的模式匹配成功，则将
         //整体匹配结果作为返回
         case List(_,e@List(_,_,_)) => e
         case _ => Nil
       }

       println(variableBindingPattern(t))
  }
}
//编译执行后的输出结果为  List(2, 3, 4)

for控制结构中的模式匹配

object PatternInForLoop {
  def main(args: Array[String]): Unit = {
    val m=Map("china"->"beijing","dwarf japan"->"tokyo","Aerican"->"DC Washington")
    //利用for循环对Map进行模式匹配输出，
    for((nation,capital) <- m)
      println(nation + ": " + capital)
  }
}

正则表达式中的模式匹配

object RegexMatch {
  def main(args: Array[String]): Unit = {
    val ipRegex="(\\d+)\\.(\\d+)\\.(\\d+)\\.(\\d+)".r
    for(ipRegex(one,two,three,four) <- ipRegex.findAllIn("192.168.1.1")){
      println("IP子段1:"+one)
      println("IP子段2:"+two)
      println("IP子段3:"+three)
      println("IP子段4:"+four)
    }
  }
}

Option类型模式匹配

简介

  Option类是一个sealed class，Some是case class，None是case object。

  case object与case class所不同的是，case object对应反编译后的CaseObject$.class中不存在apply、unapply方法。因为None不需要创建对象及进行内容提取，从这个角度讲，它被定义为case object是十分合理的。

简单实例

object OptionDemo extends App{
  val m=Map("hive"->2,"spark"->3,"Spark MLlib"->4)

  def mapPattern(t:String)=m.get(t) match {
    case Some(x) => println(x);x
    case None => println("None");-1
  }

  println(mapPattern("Hive"))
}
//输出结果为：
//None
//-1

---

忠于技术，热爱分享。欢迎关注公众号：java大数据编程，了解更多技术内容。