模式匹配：

Scala中的模式匹配相當于Java中的switch

在Java中我們有switch  case default 這三個組成的基礎語法，在Scala中我們是有match  和 case組成  default的作用由case代替

基礎語法如下：

val a=10
    val b=20
    var c='+'
    c match {
      case '+'=> println(a+b)
      case '-'=> println(a-b)
      case _  =>println("錯誤的運算符")
    }

在Scala中是默認從這個case執(zhí)行到下一個case的  

case _  是代表上述情況都不滿足

模式守衛(wèi)：

如果想要表達匹配某個范圍的數(shù)據(jù)，就需要在模式匹配中增加條件守衛(wèi)

（其實是在case中添加if判斷）

 val x=3.153
    val value: Any = x match {
      case i: Double if i >= 0 => i
      case j: Double if j < 0 => -j
      case _ => "type illegal"
    }

類型匹配：

在定義函數(shù)時 參數(shù)為所有對象的父類Any

 def function(x:Any): Unit ={
      x match {
        case s:String =>println("字符串")
        case i:Int=>println("整數(shù)")
        case d:Double=>println("小數(shù)")
        case _ =>println("其他")
      }
    }

對象匹配

對象的匹配是比較復雜的，單純的比較是比較的地址值，兩個變量的地址值是肯定不同的

object Test_03MatchObject {
  def main(args: Array[String]): Unit = {
    val sss: person1 = person1("sss", 1)
  sss match {
    case person1("sss",1)=>println("victory")
    case _=>println("defite")
  }
  }
  class person1(val name: String,val age :Int){
  }
  object person1{
    def apply(name: String, age: Int): person1 = new person1(name, age)
    def unapply(arg: person1): Option[(String, Int)] =
      if (arg==null)
      {
        None
      }
      else{
        Some(arg.name,arg.age)
      }  }
}

這里我們在object中定義了unapply方法   unapply方法相當于apply方法的逆應用，apply方法是在object中創(chuàng)建對象，而unapply方法是提取方法，提取操作的對象（傳入的參數(shù)為對象，根據(jù)對象進行提取數(shù)據(jù)存入Some，與自己的傳入的數(shù)據(jù)進行比較）這個方法也是和apply方法一樣不用寫方法名。

該方法主要用于解析對象（匹配對象）

樣例類：

樣例類中的主屬性默認為val如果需要使用var則需要自己標注

樣例類會自動生成unapply與apply等方法   節(jié)省了大量代碼

把上述的class與object注釋后新建樣例類：（大量使用）

  case class person1(val name: String,val age :Int)

偏函數(shù)：

偏函數(shù)的化簡寫法：

我們可以直接調(diào)用collect函數(shù)進行調(diào)用偏函數(shù)參數(shù)直接寫case+你需要的操作

化簡寫法相當于省掉了match,作用相當于 filter+map

在使用map的場景下也能使用偏函數(shù)

偏函數(shù)的使用：

    val list = List(List(1, 2, 3, 4), List(1), List(8, 5))
    val list1: List[Int] = list.collect({ case List(x, y, _*) => y })
  println(list1)

隱式轉(zhuǎn)換：

官方定義：

當編譯器第一次編譯失敗的時候，會在當前的環(huán)境中查找能讓代碼編譯通過的方法，用

于將類型進行轉(zhuǎn)換，實現(xiàn)二次編譯

個人理解：

隱式轉(zhuǎn)換是我們在對一個對象調(diào)用它所在的類中沒有的函數(shù)時發(fā)生錯誤所進行的操作

隱式函數(shù)：

隱式轉(zhuǎn)換的步驟：

（1）需要現(xiàn)在下邊定義一個目標類  在類中定義所調(diào)用的方法與邏輯

eg:我們對Int類型數(shù)據(jù)調(diào)用一個不存在的方法：

class MyRichInt(val self :Int)
  {
def myMax(int: Int):Int =
    {
      if (int>self)
        int
        else
        self
    }
  }

（2）在main函數(shù)中定義轉(zhuǎn)換器

在開頭要引入 ----   implicit 隱式轉(zhuǎn)換的函數(shù)再進行定義

 implicit def changeInt(self:Int)  =
    {
new MyRichInt(self)
    }

當隱式轉(zhuǎn)換的的方法相同與自身方法沖突，會使用自身的方法（因為不會編譯失敗---隱式轉(zhuǎn)換的官方定義）

隱式參數(shù)：

在定義函數(shù)時我們已經(jīng)知道了參數(shù)默認值  但是調(diào)用的時候我們需要加上括號

在這里我們引入了新概念   隱式參數(shù)

參數(shù)對比樣例：

   implicit val name:String="lisi"
    def sayhi(implicit name: String="sd"): Unit =
    {
      println(s"hi $name")
    }
   sayhi
   sayhi()

參數(shù)默認值只是在調(diào)用函數(shù)的后邊加一個括號

運行結(jié)果：

隱式類：

在普通類的前面添加關鍵字implicit會自動轉(zhuǎn)換成隱式類

如果隱式轉(zhuǎn)換的目標類轉(zhuǎn)換成隱式類 則不需要在main函數(shù)中new隱式類的

可以直接調(diào)用指定函數(shù)

以上就是Java Scala之模式匹配與隱式轉(zhuǎn)換的詳細內(nèi)容，更多關于Scala模式匹配與隱式轉(zhuǎn)換的資料請關注腳本之家其它相關文章！

最新評論