模式匹配
簡介
-
類似于java中switch
-
當資料滿足某一個分支時，執行完畢后，就直接跳出
-
case分支類似于default語言， 分支匹配其實就是順序匹配
-
如果資料沒有匹配任何規則，會發生錯誤
// val age = 20 // // age match { // //case _ => println("other") // case 10 => println("age = 10") // case 30 => println("age = 30") // } var a: Int = 10 var b: Int = 20 var operator: Char = '+' var result = operator match { case '+' => a + b case '-' => a - b case '*' => a * b case '/' => a / b case _ => "illegal" }
匹配規則
匹配常量
def describe(x: Any) = x match {
case 5 => "Int five"
case "hello" => "String hello"
case true => "Boolean true"
case '+' => "Char +"
}
匹配型別
- 型別前增加變數名稱,這個變數就是將資料轉換成指定型別的變數
- 如果想要使用下劃線代表的資料，可以給下劃線起名來使用
def describe(x: Any) = x match {
case i : Int => i + 10
case s : String => "String hello"
case m: List[_] => "List"
case c: Array[Int] => "Array[Int]"
case someThing => "something else " + someThing
}
-
scala中型別匹配時，是不考慮泛型的,但是Array型別是特殊的，
-
型別匹配注意
Array[Int], 這里的Int不是真正的泛型
java中的寫法 => String[]
scala中的寫法 => Array[String]Array[Int] 是一個整體
List[Int] 是型別加泛型
不考慮泛型演示
case m: List[Int] => "List" println(describe(List("1", "2", "3"))) ==> List case m: List[string] => "List" println(describe(List(1, 2, 3))) ==> List
-
匹配陣列
for (arr <- Array(
Array(0),
Array(1, 0),
Array(0, 1, 0),
Array(1, 1, 0),
Array(1, 1, 0, 1),
Array("hello", 90))) { // 對一個陣列集合進行遍歷
val result = arr match {
case Array(0) => "0" //匹配Array(0) 這個陣列
case Array(x, y) => x + "," + y //匹配有兩個元素的陣列，然后將將元素值賦給對應的x,y
case Array(0, _*) => "以0開頭的陣列" //匹配以0開頭和陣列
case _ => "something else"
}
println("result = " + result)
}
result = 0
result = 1,0
result = 以0開頭的陣列
result = something else
result = something else
result = hello,90
匹配串列
for (list <- Array(
List(0),
List(1, 0),
List(0, 0, 0),
List(1, 0, 0),
List(88))) {
val result = list match {
case List(0) => "0" //匹配List(0)
case List(x, y) => x + "," + y //匹配有兩個元素的List
case List(0, _*) => "0 ..."
case _ => "something else"
}
println(result)
}
0
1,0
0 ...
something else
something else
匹配元組
for (tuple <- Array(
(0, 1),
(1, 0),
(1, 1),
(1, 0, 2))) {
val result = tuple match {
case (0, _) => "0 ..." //是第一個元素是0的元組
case (y, 0) => "" + y + "0" // 匹配后一個元素是0的對偶元組
case (a, b) => "" + a + " " + b
case _ => "something else" //默認
}
println(result)
}
0 ...
10
1 1
something else
匹配物件
通過伴生物件定義unapply方法來進行物件之間的相互匹配
def main(args: Array[String]): Unit = {
// TODO - 模式匹配 - 匹配規則
// 匹配物件
// apply : Attribute => Object
val user = getUser()
// unapply : Object => Attribute
user match {
case User("zhangsan",40) => println("用戶為張三")
case _ => println("什么也不是")
}
}
class User {
var name:String = _
var age:Int = _
}
object User {
// Object => Attribute
def unapply(user: User): Option[(String, Int)] = {
Option( (user.name, user.age) )
}
// Attribute => Object
def apply( name : String, age:Int ) = {
val user = new User()
user.name = name
user.age = age
user
}
}
def getUser() = {
User("zhangsan", 30)
}
模式匹配用法
- 直接取元組value
val (_, name, _) = (1, "zhangsan", 30)
println(name) ==> zhangsan
- 直接取map的key
val map = Map(
("a", 1), ("b", 2), ("c", 3)
)
for ( (k, 2) <- map ) {
println( k ) ==> b
}
- 用模式匹配去替換 ‘_ ‘ 加索引
val list = List(
(("河北", "鞋"), 10),
(("河北", "衣服"), 20),
(("河北", "電腦"), 15),
)
list.map(
(t) => {
t
}
)
// 下面的代碼中，使用模式匹配需要注意：
// 1. 匹配資料時，需要使用case關鍵字
// 2. case分支可能存在多個，那么需要將map的小括號換成大括號
val list1 = list.map {
case ((prv, item), cnt) => {
(prv, (item, cnt * 2))
}
}
樣例類
在編譯時，會自動生成大量的方法
- 樣例類會自動實作可序列化介面
- 樣例類的構造引數直接能夠作為屬性使用，但是不能修改，如果想要修改，需要將引數使用var宣告
- 增加和重寫了大量的方法
- 樣例類自動生成伴生物件，而且其中自動宣告了apply，unapply
def main(args: Array[String]): Unit = {
val user = getUser()
user.name = "lisi"
user match {
case User("zhangsan",40) => println("用戶為張三")
case _ => println("什么也不是")
}
}
case class User(var name:String, age:Int)
def getUser() = {
User("zhangsan", 40)
}
偏函式
以偏概全
-
全量函式 ：函式進行處理時必須對所有的資料進行處理，
val list = List(1,2,3,4) // map只支持全量函式操作 // 1 => 2 // 2 => Unit // 3 => 6 // 4 => Unit val list1 = list.map( num => { if ( num % 2 != 0 ) { num * 2 } } ) println(list1) ==> List(2, (), 6, ()) -
偏函式 ： 函式進行處理時只對滿足條件的資料進行處理
// 將該List(1,2,3,4,5,6,"test")中的Int型別的元素加一，并去掉字串 val list : List[Any] = List(1,2,3,4,5,6,"test") val list1 = list.map { case i : Int => { // 只匹配Int型別 i + 1 } case other => other }.filter(_.isInstanceOf[Int]) println(list1) val list : List[Any] = List(1,2,3,4,5,6,"test") val list1 = list.collect{ case i : Int => i + 1 } println(list1)
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/520595.html
標籤：其他