Scala进阶源码实战之四——模式匹配

basic

package PatternMatch

object patternmatch {
  println("Welcome to the Scala worksheet")       //> Welcome to the Scala worksheet

      val data =2                                 //> data  : Int = 2
    data match {
        case 1 => println("First")
        case 2 => println("Second")
        case _ => println("Not Known Number")
      }                                       //> Second

    val result = data match {
      case i if i == 1 => "The First"
      case number if number ==2 => "The Second" + number
      case _ => "Not Known Number"
      }                                       //> result  : String = The Second2
    println(result)                               //> The Second2

    "Spark !" foreach { c => println (
        c match {
          case ' ' => "space"
          case ch => "Char: " + ch
        }
        )}                                    //> Char: S
                                                  //| Char: p
                                                  //| Char: a
                                                  //| Char: r
                                                  //| Char: k
                                                  //| space
                                                  //| Char: !

    //匹配类型                                          
    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: (t: Any)Unit

    match_type(2)                                 //> It is Integer
    match_type("Spark")                           //> It is String, the content is : Spark
    match_type(Map("Scala" -> "Spark"))           //> (Scala,Spark)

    def match_array(arr : Any) = arr match {
      case Array(0) => println("Array:" + "0")
      case Array(x, y) => println("Array:" + x + " " +y)
      case Array(0, _*) => println("Array:" + "0 ...")  //*代表多个
      case _ => println("something else")
    }                                         //> match_array: (arr: Any)Unit

    match_array(Array(0))                         //> Array:0
    match_array(Array(0,1))                       //> Array:0 1
    match_array(Array(0,1,2,3,4,5))               //> Array:0 ...


    def match_list(lst : Any) = lst match {
      case 0 :: Nil => println("List:" + "0")          //nil 代表开头
      case x :: y :: Nil => println("List:" + x + " " + y)
      case 0 :: tail => println("List:" + "0 ...")
      case _ => println("something else")
    }                                         //> match_list: (lst: Any)Unit

    match_list(List(0))                           //> List:0
    match_list(List(3,4))                         //> List:3 4
    match_list(List(0,1,2,3,4,5))                 //> List:0 ...


    def match_tuple(tuple : Any) = tuple match {
    case (0, _) => println("Tuple:" + "0")
    case (x, 0) => println("Tuple:" + x )
    case _ => println("something else")
    }                                             //> match_tuple: (tuple: Any)Unit

    match_tuple((0,"Scala"))                      //> Tuple:0
    match_tuple((2,0))                            //> Tuple:2
    match_tuple((0,1,2,3,4,5))                    //> something else
}

提取器

package PatternMatch

object extrator {
  println("Welcome to the Scala worksheet")       //> Welcome to the Scala worksheet

  def match_array(arr : Any) = arr match {
      case Array(0) => println("Array:" + "0")
      case Array(x, y) => println("Array:" + x + " " +y)
      case Array(0, _*) => println("Array:" + "0 ...")
      case _ => println("something else")
    }                                         //> match_array: (arr: Any)Unit

    match_array(Array(0))                         //> Array:0
    match_array(Array(0,1))                       //> Array:0 1
    match_array(Array(0,1,2,3,4,5))               //> Array:0 ...

    val pattern = "([0-9]+) ([a-z]+)".r           //> pattern  : scala.util.matching.Regex = ([0-9]+) ([a-z]+)
        "20150628 hadoop" match {
          case pattern(num, item) => println(num + " : " + item)
        }                                 //> 20150628 : hadoop



}

case class

package PatternMatch




object casecalss {
  println("Welcome to the Scala worksheet")       //> Welcome to the Scala worksheet


 abstract class Person
 case class Student(age: Int) extends Person
 case class Worker(age: Int, salary: Double) extends Person
 case object Shared extends Person

  def caseOps(person: Person) =  person match {
          case Student(age) => println("I am " + age + "years old")
          case Worker(_, salary) => println("Wow, I got " + salary)
          case Shared => println("No property")
          }                               //> caseOps: (person: PatternMatch.casecalss.Person)Unit
      caseOps(Student(19))                    //> I am 19years old
      caseOps(Shared)                         //> No property

  val worker = Worker(29, 10000.1)                //> worker  : PatternMatch.casecalss.Worker = Worker(29,10000.1)
  //def copy(age: Int, salary: Double): Worker
    val worker2 = worker.copy(salary = 19.95) //> worker2  : PatternMatch.casecalss.Worker = Worker(29,19.95)
    val worker3 = worker.copy(age = 30)       //> worker3  : PatternMatch.casecalss.Worker = Worker(30,10000.1)


    //Option_Internal
      val scores = Map("Alice" -> 99, "Spark" -> 100)
                                                  //> scores  : scala.collection.immutable.Map[String,Int] = Map(Alice -> 99, Spar
                                                  //| k -> 100)

    scores.get("Spark") match {
      case Some(score) => println(score)
      case None => println("No score")
    }                                         //> 100
}