基本模式匹配：

点击(此处)折叠或打开

def main(args: Array[String]) {
val data =2
data match {
case 1 => println("First") //类似于函数的定义与实现（case可以是变量，也可以是条件表达式）
case 2 => println("Second") //不同于java，这里不需要break关键字，匹配之后会自动返回
case _ => println("Not Known Number") //默认情况
}
val result = data match { //match可以返回结果
case i if i == 1 => "The First" //val i常量，使用match时，data传进来时就会赋值给i
case number if number ==2 => "The Second" + number //number的初始化同i，并且number在case语句，以及函数体中都可以被使用。
case _ => "Not Known Number"
}
println(result)
"Spark !" foreach { c => println (
c match {
case ' ' => "space"
case ch => "Char: " + ch
}
)}
}

Type模式匹配：

点击(此处)折叠或打开

def match_type(t : Any) = t match {
case p : Int => println("It is Integer")
case p : String => println("It is String, the content is : " + p)
case m: Map[_, _] => m.foreach(println)
case _ => println("Unknown type!!!")
}
match_type(2)
match_type("Spark")
match_type(Map("Scala" -> "Spark"))

结果：
It is Integer
It is String, the content is : Spark
(Scala,Spark)

Array模式匹配：

点击(此处)折叠或打开

def match_array(arr : Any) = arr match {
case Array(0) => println("Array:" + "0") //匹配Array只有1个元素，而且是0
case Array(x, y) => println("Array:" + x + " " +y) //匹配两个元素
case Array(0, _*) => println("Array:" + "0 ...") //匹配至少1个元素，而且第一个元素是0
case _ => println("something else")
}
match_array(Array(0))
match_array(Array(1,2))
match_array(Array(0,1,2,3,4,5))

结果：
Array:0
Array:1 2
Array:0 ...

List模式匹配：

点击(此处)折叠或打开

def match_list(lst : Any) = lst match {
case 0 :: Nil => println("List:" + "0") //匹配List只有一个元素，而且是0
case x :: y :: Nil => println("List:" + x + " " + y) //匹配List有两个元素
case 0 :: tail => println("List:" + "0 ...") //匹配List至少有一个元素，而且第一个元素是0
case _ => println("something else")
}
match_list(List(0))
match_list(List(3,4))
match_list(List(0,1,2,3,4,5))

结果：
List:0
List:3 4
List:0 ...

Tuple模式匹配：

点击(此处)折叠或打开

def match_tuple(tuple : Any) = tuple match {
case (0, _) => println("Tuple:" + "0") //匹配第一个元素是0，第二个任意
case (x, 0) => println("Tuple:" + x ) //匹配第一个元素任意，第二个元素是0
case _ => println("something else")
}
match_tuple((0,"Scala"))
match_tuple((2,0))
match_tuple((0,1,2,3,4,5))

结果：
Tuple:0
Tuple:2
something else

case class与case object模式匹配：

点击(此处)折叠或打开

abstract class Person
//每个case class都会有一个伴生对象，apply方法负责创建case class的实例
case class Student(age: Int) extends Person //默认声明为val，不可变
case class Worker(age: Int, salary: Double) extends Person
case object Shared extends Person
object case_class_object {
def main(args: Array[String]){
//面向接口（Persion）
def caseOps(person: Person) = person match {
case Student(age) => println("I am " + age + "years old") //从传进来的person对象中析取age值，构造新的Student对象，这个提取动作发生在伴生对象的unApply方法中
case Worker(_, salary) => println("Wow, I got " + salary)
case Shared => println("No property")
}
caseOps(Student(19))
caseOps(Shared)
val worker = Worker(29, 10000.1) //apply调用
val worker2 = worker.copy(salary = 19.95) //拷贝一个新的对象，并且重新赋值
val worker3 = worker.copy(age = 30)
}
}

用途：传递消息与模式匹配，spark中worker与master进行通信的时候，传递case class或者case object，接收消息后再进行模式匹配。

嵌套case class的模式匹配：

点击(此处)折叠或打开

def main(args: Array[String]) {
def caseclass_nested(item: Item) = item match {
case Bundle(_, _, art @ Book(_, _), rest @ _*) => println(art.description + " : " + art.price) //使用@符号可以引用这个对象
case Bundle(_, _, Book(descr, _), _*) => println("The first description is :" + descr)
case _ => println("Oops!")
}
caseclass_nested(Bundle("1111 Special's", 30.0,
Book("Scala for the Spark Developer", 69.95),
Bundle("Hadoop", 40.0,
Book("Hive", 79.95),
Book("HBase", 32.95)
)
))
caseclass_nested(Bundle("1212 Special's", 35.0,
Book("Spark for the Impatient", 39.95)
))
}

Option的使用：

点击(此处)折叠或打开

sealed abstract class Option[+A] extends Product with Serializable

点击(此处)折叠或打开

final case class Some[+A](x: A) extends Option[A] {
def isEmpty = false
def get = x
}

点击(此处)折叠或打开

case object None extends Option[Nothing] {
def isEmpty = true
def get = throw new NoSuchElementException("None.get")
}

sealed：强制要求，Option下定义的的case class（Some）或者case object（None）都必须在同一个文件中。

点击(此处)折叠或打开

def main(args: Array[String]){
val scores = Map("Alice" -> 99, "Spark" -> 100)
scores.get("Spark") match { //Map的get方法返回Option类型的值
case Some(score) => println(score)
//或者这样：
case a @ Some(score) => println(a.get)
case None => println("No score")
}
}

模式匹配下的for循环
object For_Advanced {
def main(args: Array[String]): Unit = {
    for(i <- List(1,2,3,4,5) ) {println(i)}

    //变量绑定，给Flink设置别名，然后模式匹配值
    for(index@"Flink" <- List("Hadoop","Spark","Flink") ) {println(index)} //Flink

    //模式匹配具体的值
    for ((language,"Hadoop") <- Set("Scala"->"Spark","Java"->"Hadoop") ) println(language) //Java

    //模式匹配类型
    for((k,v:Int) <- List(("Spark"->5),("Hadoop"->"Big Data"))) {println(k)}
}
}

模式匹配下的赋值语句

点击(此处)折叠或打开

object Assinment_Internals {
def main(args: Array[String]) {
val a@b = 1000 //a是b别名，模式匹配后返回二元Tuple(a, b)
println("a = " + a + ", b = " + b)
val (c,d) = (1000,2000)
// val (e,F) = (1000,2000) //F大写的话会把它当成常量，而常量未定义则会报错
val Array(g,h) = Array(1000,2000)
// val Array(i,J) = Array(1000,2000)
// object Test { val 1 = 1 } //看传进来的值是否匹配1
object Test { val 1 = 2 } //编译器lazy匹配，所以编译通过，但是运行报错
}
}

ITPub博客

Scala模式匹配

最新文章