Scala学习笔记之case模式匹配

Java里有 switch 关键字来做模式匹配，Scala里 case 关键字发挥同样的作用

模式匹配类型

常见的模式匹配类型有常量模式，变量模式，构造器模式，序列模式，元组模式以及变量绑定模式等等。

1、常量模式

顾名思义，常量模式就是匹配常量

object Test{
  def main(args: Array[String]) {

    def constantPattern(x: Any) = x match{
      case 1 => "one"
      case true => "真"
      case "test" => "字符串"
      case null => "null值"
      case Nil => "空列表"
      case _ => "其他常量"
    }

    println(constantPattern(1))
    println(constantPattern(null))
    println(constantPattern(Nil))
    println(constantPattern(3))
  }
}

// 运行结果
one
null值
空列表
其他常量

2、变量模式

变量匹配是指 case 后面跟的是Scala 变量

object Test{
  def main(args: Array[String]) {
    def variablePattern(x: Any) = x match{
      case x if(x == 5) => "x = 5"
      case x if(x == "Scala") => "x is Scala"
      case _ => "something else"
    }
    println(variablePattern(5))
    println(variablePattern(3))
    println(variablePattern("Scala"))
  }
}

// 运行结果
x = 5
something else
x is Scala

3、构造器模式

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

case class person(name: String, age: Int)

object Test{
  def main(args: Array[String]) {
    val p = new person("Tom", 13)
    def classPattern(p: person) = p match{
      case person(name, age) => "name: " + name + " age: " + age
      case person(_, age) => "age: " + age
      case _ => "who?"
    }

    println(classPattern(p))
  }
}

// 运行结果
name: Tom age: 13

4、序列化模式

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

object Test{
  def main(args: Array[String]) {
    val list = List("Spark","Hive","Kafka")
    val array = Array("SparkMLlib", "SparkStreaming", "SparkSQL")
    def sequencePattern(p: Any) = p match{
      case Array(first, second, _*) => first + "," + second
      case List(_, second, _*) => second
      case _ => "Other"
    }

    println(sequencePattern(list))
    println(sequencePattern(array))
  }
}

// 运行结果
Hive
SparkMLlib,SparkStreaming

5、元组模式

object Test{
  def main(args: Array[String]) {
    val list = List("spark","Hive","SparkSQL")
    val t = ("a", "b", "c")
    def tuplePattern(t : Any) = t match {
        case (one,_,_) => one
        case _ => "Other"
    }
    println(tuplePattern(list))
    println(tuplePattern(t))
  }
}

// 运行结果
Other
a

6、类型模式

匹配输入待匹配变量的类型

object Test{
  def main(args: Array[String]) {
    def typePattern(t: Any) = t match {
        case t: String => "String"
        case t: Double => "Double"
        case t: Int => "Int"
        case _ => "Other type"
    }
    println(typePattern(5.0))
    println(typePattern(5))
    println(typePattern("5"))
    println(typePattern(List()))
  }
}

// 运行结果
Double
Int
String
Other type

7、变量绑定模式

在进行模式匹配时，有时不仅仅只是返回一个变量，也可以将某个变量绑定到某个模式上。从而将整体匹配结果赋值给该变量。
具体使用方法是在模式前面加变量和 @ 符号

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

// 运行结果
List(4, 5, 6)