Scala这一路 之 模式匹配

摘要：Scala 提供了强大的模式匹配机制，应用也非常广泛。

一个模式匹配包含了一系列备选项，每个都开始于关键字 case。每个备选项都包含了一个模式及一到多个表达式。箭头符号 => 隔开了模式和表达式。

1. 模式类型

   1. 常量类型

      object ConstantPattern{
        def main(args: Array[String]): Unit = {
          def patternShow(x:Any)=x match {
            case 3 => "three"
            case true=>"true"
            case "yes"=>"是"
            case null=>"null"
            case Nil=>"empty list"
            case _  =>"Other constant"
          }    
          println(patternShow(3))
        }
      }

   2. 变量类型

      object VariablePattern{
        def main(args: Array[String]): Unit = {
          def patternShow(x:Any)=x match {
            case 3 => "three"
            case y => y
          }   
          #不是3的值都是匹配y，例如输入m，输出m
          println(patternShow("m"))
        }
      }
      
      #####out
      
      scala> :load VariablePattern.scala
      :load VariablePattern.scala
      Loading VariablePattern.scala...
      defined object VariablePattern
      
      scala> VariablePattern.main(null)
      VariablePattern.main(null)
      
      m
      
      scala>

   3. 构造器模式

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

   4. 序列模式

      #序列模式指的是像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))
        }
      }

   5. 元组模式

      # 匹配某个元组内容
      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))
        }
      }
      
      

   6. 类型模式

      # 匹配传入参数的类型
      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))
        }
      }
      #上述代码如果不用模式匹配的话，要实现相同的功能，可以通过下列代码实现：
      
      def tuplePattern2(t:Any)={
              if(t.isInstanceOf[String]) "String"
              else if(t.isInstanceOf[Int]) "Int"
              else if(t.isInstanceOf[Double]) "Double"
              else if(t.isInstanceOf[Map[_,_]]) "MAP"
            }

   7. 变量绑定模式

      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)

2. 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)
     }
   }

3. 正则表达式中的模式匹配

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

END~