在匹配某个范围的数据，需要在模式匹配中增加条件守卫。
变量 match {
case 匹配条件 => 处理逻辑
case 匹配条件 => 处理逻辑
case 匹配条件 => 处理逻辑
case _ => 其他处理 //case x => 其他条件 如果x不在箭头右边使用，则可以用_代替
}
语法
变量 match {
case 值1 => ...
case 值2 => ...
case _ => ....
}
示例
x match {
case 5 => "Int five"
case "hello" => "String hello"
case true => "Boolean true"
case ‘+‘ => "Char +"
}
语法
变量 match {
//首先要满足指定类型，然后还要满足后面判断条件，才算匹配上
case x:类型 if 布尔表达式 => ....
}
示例
val x = 10
x match {
case i: Int if i >= 0 => i
case j: Int if j < 0 => -j
case _ => "type illegal"
}
语法
变量 match{
case x:类型1 => ... //如果x不需要在=>右边使用,可以用_代替
case _:类型2 => ...
case x:类型3 => ...
示例
line match {
case =>
println(s"string:${line}")
x.length
case x:Int =>
println(s"int:${line}")
x*x
case x:Double =>
println(s"double:${line}")
x*x
case x:Boolean =>
println(s"boolean:${line}")
if(x) 1 else 0
case _ => println("其他类型")
}
示例
val arr = Array[Any](1,"hello",9)
arr match {
//匹配当前数组有4个元素
case Array(x,y,z,e) => println(s"${x} $y $z $e")
//匹配数组以0开头
case Array(0,_*) => println("数组以0开头，元素的个数>=1")
//匹配元素的类型
case Array(x:Int,y:String,z:Int) => println(s"--- ${x} $y $z")
//匹配数组有三个元素，只需要中间一个元素
case Array(_,x,_) => println(s"${x}")
}
示例
方式一：固定的List匹配
list match {
//list有多少元素，只有前两个会用到,其余可以用_代替。
case List(x,y,_,_,_,_,_) =>
println(s"list有7个元素,前两个 ${x} ${y}")
//匹配List至少包含两个元素，且第一个元素是Int类型,第二个元素是String
case List(x:Int,_*) =>
println("第一个为Int,第二个为string")
//匹配List的首位元素是固定值，后续的元素不要求
//匹配List至少有一个元素
case List(x,_*) =>
println(s"首位元素是 ${x}")
case _ => println("其他情况")
}
方式二：::方式
list match {
//只有三个元素
case x :: y :: z :: Nil => println("当前List有三个元素")
//x是第一个元素，tail是剩余元素组成的List
case x :: tail => println(s"匹配首位元素 ${x} 剩余部分:${tail}")
//前两个元素Int类型x、Int类型，tail是其余元素组成的List
case (x:Int) :: (y:Int) :: tail => println("匹配list至少两个元素，第一个为int，第二个int")
case _ => println("+++++++++++++++++")
}
泛型擦除：
如果在匹配类型的时候，List中的泛型在运行的时候会擦除，导致 x:List[String] x:List[Int]的匹配效果一样
示例
val arr = List[Int](1,"hello",false,10.0,2)
arr match{
case x:List[String] => println("....")
case x:List[Int] => println("++++++")
}
//以上会匹配到第一个条件.
示例
val t1:(Any,Any,Any) = ("zhangsan",20,"shenzhen")
t1 match {
//匹配元组的元素,在匹配的时候元组的长度要和变量的元组长度要一致
case (name:String,age:Int,address:String) =>
println("name string,age int,address string")
//要想匹配元组元素的类型，变量中数据的类型必须设置为Any
case (name:Int,age:String,address:String) =>
println("name int,age string,address string")
case (name,age,address) => println(s"${name} ${age} ${address}")
}
1.样例类
定义语法：case class 类名([val/var] 属性名:类型,...)
? 属性默认就是val修饰的
? 直接用于模式匹配
创建样例类对象：case_class_类名(值,..)
示例
//样例类
case class Person(name:String,age:Int)
val person:Any = Person("zhangsan",20)
//对象匹配
person match {
case Person(name,age) => println(s"name=${name} age=${age}")
}
2.普通类
如果想要让普通的class能够用于模式匹配。需要在伴生对象中创建unapply方法
//普通类AA
class AA(val name:String,val age:Int)
object AA{
def apply(name:String,age:Int) = new AA(name,age)
//unapply如果返回的Some,代表能够匹配上,如果返回的是None,代表不能匹配上
def unapply(arg: AA): Option[(String, Int)] = Some(arg.name,arg.age)
}
定义: 没有match关键字的模式匹配
语法
val 函数名:PartialFunction[A,B] = {
case ...
case ...
}
//A: 入参的类型
//B：返回值的类型
应用场景
val list = List[(String,(String,(String,Int)))] (
("A",("1001",("zhangsan",20))),
("A",("1002",("lisi",20))),
("A",("1003",("wangwu",20))),
)
list.map({
case (schoolName, (className, (studentName, age))) => age
})
示例
val (name,age) = ("zhangsan",20)
val List(x,y,z,_*) = List(1,2,3,4,5,6,7)
示例
val map = Map[String,Int](...)
for( (K,V) <- map) {
...
}
原文：https://www.cnblogs.com/wh984763176/p/13391608.html