模式匹配的类型

包括:

  • 常量模式
  • 变量模式
  • 构造器模式
  • 序列模式
  • 元组模式
  • 变量绑定模式等。

常量模式匹配

常量模式匹配,就是在模式匹配中匹配常量

objectConstantPattern{
  def main(args:Array[String]) :Unit = {
    //模式匹配结果作为函数返回值
    defpatternShow(x : Any) = x match {
      case => "五"
      case true => "真"
      case "test" => "字符串"
      case null => "null值"
      case Nil => "空列表"
      case _ => "其他常量"
    }
    println(patternShow())
    println(patternShow(true))
    println(patternShow(List()))
  }
}

变量匹配

变量匹配,匹的是case语句后面接的是scala变量,如case x if(x == 5) => x等,在使用时一般会加守卫条件,当然也可以像case x => x这样使用,它会匹配任何输入的合法变量。

objectVariablePattern{
  def main(args:Array[String]) :Unit = {
  //模式匹配结果作为函数返回值
  defpatternShow(x : Any) = x match {
    case x if (x == ) => x
    case x if (x == "Scala") => x
    case _ =>
  }
  println(patternShow())
  println(patternShow("Scala"))
  }
}

构造器模式

构造器模式指的是,直接在case语句后面接类构造器,匹配的内容放置在构造器参数中。

//将Person类定义为case class
case class Person(name : String,age : Int) object ConstructorPattern{
    def main(args:Array[String]) :Unit = {
      val p = new Person("nyz",)
      def constructorPattern(p : Person) = p match {
        //构造器模式必须将Person类定义为case class,否则需要自己定义伴生对象并实现unapply方法。
        case Person(name,age) => "name =" + name + ",age =" + age
        //case Person(_,age) => "age =" + age
        case _ => "Other"
      }
      println(constructorPattern(p))
    }
}

序列化模式

序列模式用于匹配如数组Array、列表List、Range这样的线性结构集合,其实原理也是通过case class起作用的。

object SequencePattern{
  def main(args:Array[String]) :Unit = {
    val list = List("spark","Hive","SparkSQL")
    val arr = Array("SparkR","Spark Streaming","Spark MLib")
  def sequencePattern(p : Any) = p match {{
    //序列模式匹配,_*表示匹配剩余内容,first、second匹配数组p中的第一、二个元素
    case Array(first,second,_*) => first + "," + second
    //_匹配数组p的第一个元素,但不赋给任何变量
    case List(_,second,_*) => second
    case _ => "Other"
  }
  println(SequencePattern(list))
  println(SequencePattern(arr))
  }
}

元组模式

元组模式用于匹配scala中的元组内容,用于匹配元组类型的变量内容

object TuplePattern{
  def main(args:Array[String]) :Unit = {
    val list = List("spark","Hive","SparkSQL")
  def tuplePattern(t : Any) = t match {{
    case (one,_,_) => one
    //_*不适合用于元组,只适用于序列
    //case (one,_*) => one
    case _ => "Other"
  }
  println(tuplePattern(t))
  }
}

类型模式

它可以匹配输入待匹配变量的类型

object TypePattern{
  def main(args:Array[String]) :Unit = {
  def typePattern(t : Any) = t match {
    case t : String => "String"
    case t : Int => "Intger"
    case t : Double => "Double"
    case _ => "Other Type"
  }
}

变量绑定模式

在进行模式匹配时,有时不仅仅只是返回一个变量,也可以将某个变量绑定到某个模式上。从而将整体匹配结果赋值给该变量。
 

具体使用方法是在模式前面加变量和@符号。

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