1. 程式人生 > >scala裡的模式匹配和Case Class

scala裡的模式匹配和Case Class

模式匹配的簡介

  scala語言裡的模式匹配可以看作是java語言中switch語句的改進。

模式匹配的型別

  包括:常量模式、變數模式、構造器模式、序列模式、元組模式以及變數繫結模式等。

常量模式匹配

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

objectConstantPattern{
  def main(args:Array[String]) :Unit = {
    //模式匹配結果作為函式返回值
    defpatternShow(x : Any) = x match {
      case 5 => "五"
      case true => "真"
      case "test" => "字串"
      case null => "null值"
      case Nil => "空列表"
      case _ => "其他常量"
    }
    println(patternShow(5))
    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 == 5) => x
    case x if (x == "Scala") => x
    case _ => 
  }
  println(patternShow(5))
  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",27)
      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"
  }
  println(typePattern(5.0))
  println(typePattern(5))
  println(typePattern("5"))
  println(typePattern(List()))
  }
}

變數繫結模式
  在進行模式匹配時,有時不僅僅只是返回一個變數,也可以將某個變數繫結到某個模式上。
  從而將整體匹配結果賦值給該變數。
具體使用方法是在模式前面加變數和@符號。
object VariableBindingPattern{
  def main(args:Array[String]) :Unit = {
    var t = List(List(1,2,3),List(2,3,4))
  def variableBindingPattern(t : Any) = t match {{
    //變數繫結,採用變數名(這裡是e)
    //與@符號,如果後面的模式匹配成功,則將整體匹配結果作為返回值
    case List(_,[email protected](_,_,_)) => e
    case _ => Nil
  }
  println(variableBindingPattern(t))
  }
}

package com.dt.spark.scala.basics


class DataFrameWork
case class ComputationFramework(name : String, popular : Boolean) extends DataFrameWork
case class StorageFramework(name : String, popular : Boolean) extends DataFrameWork


object HelloPatternMatch {
  def main(args: Array[String]): Unit = {
    getSalary("Hadoop MapReduce")
    // getSalary("cdcdc",6)

    getMatchType(100)

    getMatchCollection(Array("Spark","Python"))
  
    getBigDataType(ComputationFramework("Spark",true))
    getBigDataType(ComputationFramework("Spark",false))
    getBigDataType(StorageFramework("HDFS",true))

    getValue("Spark",Map("Spark" -> "The hottest!" , "Hadoop " -> "The old !"))
  }

  //對於匹配模式來說,不需什麼break,只要匹配到,就不往下了
  def getSalary(name : String) {
  // def getSalary(name : String,age : Int) {
    name match {
      case "Spark" => println("$1500/year")//表示,如果傳入是Spark,則說明匹配成功,執行=>後的語句
      case "Hadoop" => println("$1000/year")
      case _ if name == "Scala" => println("$1800/year")//_ if name == "Scala"是守衛條件的方式,
      case _ if name == "Hadoop MapReduce" => println("$800/year")
      // case _name if age >= 5 => println("name : " + _name + " age : " + age + "$100/year")//getSalary("cdcdc",6)
      case _ => println("$90/year")//_是前面沒匹配的。即其他

      //如case _ if (i%4 ==0) => println("$1800/year")這是帶守衛條件的方式,對變數的值進行判斷。

    }
  }


  def getMatchType(msg : Any) {
    msg match {
      case i : Int => println("Integer")
      case s : String => println("String")
      case d : Double => println("Double")
      case array : Array[Int] => println("Array")
      case _ => println("Unkoen type")
    }
  }



  def getMatchCollection(msg : Any) {
    msg match {
      case Array("Scala") => println("One element")
      case Array("Scala","Java")=> println("Two element")
      case Array("Spark", _*) => println("Many elements begins with Spark")
      case _ => println("Unkoen type")
    }
  }



  def getBigDataType(data : DataFrameWork) {
    data match {
      case ComputationFramework(name, popular) => println("ComputationFramework : " + "name : " + name + "popular : " + popular)
      case StorageFramework(name, popular) => println("StorageFramework : " + "name : " + name + "popular : " + popular)
      case _ => println("Some other type")
    }
  }  


  def getValue(key : String , content : Map[String,String]){
    content.get(key) match {
      case Some(value) => println(value)
      case None => println("Not Found!!!")
    }
  }

相關推薦

scala模式匹配Case Class

模式匹配的簡介  scala語言裡的模式匹配可以看作是java語言中switch語句的改進。模式匹配的型別  包括:常量模式、變數模式、構造器模式、序列模式、元組模式以及變數繫結模式等。常量模式匹配  常量模式匹配,就是在模式匹配中匹配常量啦。objectConstantPa

Scala模式匹配樣例類

1. 模式匹配 1.1. 更好的 Switch Scala 中類似 Java 的 switch 程式碼: object PatternDemo { def main(args: Array[String]): Unit = { var sign = 0 val ch

Scala classcase class的區別

arr 實現 array data https arch ctu alt 序列 在Scala中存在case class,它其實就是一個普通的class。但是它又和普通的class略有區別,如下: 1、初始化的時候可以不用new,當然你也可以加上,普通類一定需要加new; s

Scala筆記整理(七):模式匹配樣例類

大數據 Scala [TOC] 可以用到switch語句 1、Scala強大的模式匹配機制,可以應用在switch語句、類型檢查以及“析構”等場合。 def swithOps: Unit ={ var sign = 0 val ch: Char = ‘+‘ ch match

Scala模式匹配 match case

1.匹配字串/型別/守衛 val arr = Array("YoshizawaAkiho", "YuiHatano", "AoiSola") val i = Random.nextInt(arr.length) println(i) val name = arr(i) println(n

Scala基礎:模式匹配樣例類

模式匹配 package com.zy.scala import scala.util.Random /** * 模式匹配 */ object CaseDemo { def main(args: Array[String]): Unit = { //匹配字串

scala中的模式匹配樣例類

目錄 模式匹配 模式匹配中的守衛和變數 物件模式匹配 陣列模式匹配  列表模式匹配 元組模式匹配 樣例類(cass class) 匹配巢狀結構 Option的使用 偏函式 模式匹配 模式匹配是scala中的另一個特色,比java中的swi

scala函數語言程式設計》之模式匹配異常處理

package com.lyzx.day20181006 import java.io.{FileNotFoundException, FileReader, IOException} class MatchTest { /** * match 對應 Java

快學Scala學習筆記及習題解答(12-14高階函式、集合、模式匹配樣例類)

本文Scala使用的版本是2.11.8 第12章 高階函式 12.1 基本用法 作為值得函式 import scala.math._ val num = 3.14 // ceil函式後的_表示這是個函式,而不是忘記傳參 val fun =

scala習題(14)——模式匹配樣例類

14.1 JDK發行包有一個src.zip檔案包含了JDK的大多數原始碼。解壓並搜尋樣例標籤(用正則表示式case [^:]+:)。然後查詢以//開頭幷包含[Ff]alls?thr的註釋,捕獲類似// Falls through或// just fall thr

Scala模式匹配樣例類

Scala模式匹配和樣例類 Scala有一個十分強大的模式匹配機制,可以應用到很多場合,如switch語句、型別檢查等,並且scala還提供了樣例類,對模式匹配進行了優化,可以快速匹配  1.匹配字串 package pricate import scala.util.Rand

《快學scala》學習筆記--第14章 模式匹配樣例類

本篇學習筆記是第二遍看《快學scala》所寫,對scala語言有一定的基礎 14.1 更好的switch val ch: Char = '*' ch match { case '+' => println("加法")

spark筆記之模式匹配樣例類

數組 object c spa 協調 一個 數據 好的 處理 zookeepe 階有一個十分強大的模式匹配機制,可以應用到很多場合:如開關語句,類型檢查等並且階還提供了樣例類,對模式匹配進行了優化,可以快速進行匹配。1.1。匹配字符串 package cn.itcast.c

scala筆記-模式匹配(14)

模式匹配 // Scala是沒有Java中的switch case語法的,相對應的,Scala提供了更加強大的match case語法,即模式匹配,類替代switch case,match case也被稱為模式匹配 // Scala的match case與Java的switch ca

聊聊 scala模式匹配

一. scala 模式匹配(pattern matching) pattern matching 可以說是 scala 中十分強大的一個語言特性,當然這不是 scala 獨有的,但這不妨礙它成為 scala 的語言的一大利器。 scala 的 pattern matching 是類似這樣的, e mat

[筆記遷移][Spark開發語言][Scala][11]模式匹配

一、概述 模式匹配,類似Java的switch-case語句。 但Scala的模式匹配除了可以對值進行匹配之外,還可以對型別進行匹配,對Array和List的元素進行匹配,對case class(即樣例類)進行匹配,甚至對有無值(Option)進行匹配 二、基

Scala - 07 - 模式匹配

Scala中的模式匹配的功能可以應用到switch語句、型別檢查、“解構”等多種場合。 簡單匹配 Scala的模式匹配最常用於match語句中。Scala的match語句類似Java裡的switch。 匹配例項: def color(num: Int): Strin

話說模式匹配(6) case類的細節

我們在第二篇文章裡曾提到過: 本質上case class是個語法糖,對你的類構造引數增加了getter訪問,還有toString, hashCode, equals 等方法; 最重要的是幫你實現了一個伴生物件,這個伴生物件裡定義了apply方法和unapply方法。 現在我們來詳細的分析一

Scala模式匹配

1.典型的模式匹配場景 (1)匹配字串 object Test01 { def main(args: Array[String]): Unit = { val arr=Array("aa","bb","cc") //隨機獲取陣列的任意元素 val index=Random.ne

scala 常用模式匹配類型

tor 結果 sparksql 伴生對象 結構 any bsp case 使用方法 模式匹配的類型 包括: 常量模式 變量模式 構造器模式 序列模式 元組模式 變量綁定模式等。 常量模式匹配 常量模式匹配,就是在模式匹配中匹配常量 objec