ITPub博客

首页 > 应用开发 > Java > Scala模式匹配

Scala模式匹配

原创 Java 作者:541732025 时间:2015-12-08 19:46:01 0 删除 编辑
基本模式匹配:

点击(此处)折叠或打开

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

Type模式匹配:

点击(此处)折叠或打开

  1. def match_type(t : Any) = t match {
  2.     case p : Int => println("It is Integer")
  3.     case p : String => println("It is String, the content is : " + p)
  4.     case m: Map[_, _] => m.foreach(println)
  5.     case _ => println("Unknown type!!!")
  6.     }
  7.     
  8.     match_type(2)
  9.     match_type("Spark")
  10.     match_type(Map("Scala" -> "Spark"))
结果:
It is Integer
It is String, the content is : Spark
(Scala,Spark)

Array模式匹配:

点击(此处)折叠或打开

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

List模式匹配:

点击(此处)折叠或打开

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

Tuple模式匹配:

点击(此处)折叠或打开

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

case class与case object模式匹配:

点击(此处)折叠或打开

  1. abstract class Person
  2. //每个case class都会有一个伴生对象,apply方法负责创建case class的实例
  3. case class Student(age: Int) extends Person //默认声明为val,不可变
  4. case class Worker(age: Int, salary: Double) extends Person
  5. case object Shared extends Person

  6. object case_class_object {
  7.   def main(args: Array[String]){
  8.    
  9.     //面向接口(Persion)
  10.      def caseOps(person: Person) = person match {
  11.          case Student(age) => println("I am " + age + "years old") //从传进来的person对象中析取age值,构造新的Student对象这个提取动作发生在伴生对象的unApply方法中
  12.          case Worker(_, salary) => println("Wow, I got " + salary)
  13.          case Shared => println("No property")
  14.          }
  15.      caseOps(Student(19))
  16.      caseOps(Shared)
  17.     
  18.     val worker = Worker(29, 10000.1) //apply调用
  19.     val worker2 = worker.copy(salary = 19.95) //拷贝一个新的对象,并且重新赋值
  20.     val worker3 = worker.copy(age = 30)
  21.   }
  22. }
用途:传递消息与模式匹配,spark中worker与master进行通信的时候,传递case class或者case object,接收消息后再进行模式匹配

嵌套case class的模式匹配:

点击(此处)折叠或打开

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

Option的使用:

点击(此处)折叠或打开

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

点击(此处)折叠或打开

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

点击(此处)折叠或打开

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

sealed:强制要求,Option下定义的的case class(Some)或者case object(None)都必须在同一个文件中。

点击(此处)折叠或打开

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

模式匹配下的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)}
  }
}

模式匹配下的赋值语句

点击(此处)折叠或打开

  1. object Assinment_Internals {

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

来自 “ ITPUB博客 ” ,链接:http://blog.itpub.net/28912557/viewspace-1868605/,如需转载,请注明出处,否则将追究法律责任。

下一篇: Scala的List
请登录后发表评论 登录
全部评论

注册时间:2013-05-23

  • 博文量
    127
  • 访问量
    479570