一：样本类就是使用case关键字声明的类，和普通类的用法都一致。
package 样本类和模式匹配
/**
* @Author:Alex_lei
* @Description:
*/
object Case_class {
/**
* people就是样本类
* @param name 名字属性
* @param age 年龄属性
*/
case class people(name:String,age:Int)
def main(args: Array[String]): Unit = {
val p1 = people("alex",23)
val p2 = people("Lily",22)
println(p1)
}
}
二：模式匹配
模式分为：通配符，常量模式，变量模式，构造器模式，序列模式，元组模式，类型模式。
代码示例：
package 样本类和模式匹配
import math.{E, Pi}
/**
* @Author:Alex_lei
* @Description: 几种模式的种类
*/
object Mode {
case class people(name:String,age:Int)
def main(args: Array[String]): Unit = {
/**
* 测试通配符
*/
catch_all(3)
println(describe(5))
/**
* 3.变量模式,在此例子中，pi是变量模式，所以它可以匹配任意值，所以后续的值不会匹配。
*/
val pi = Pi
val res = E match {
case pi => "pi"
case _ => "OK"
}
println(res)
/**
* 测试构造器模式
*/
val p = people("alex",22)
Constructor_mode(p)
/**
* 5.序列模式，匹配如List或Array这样的类型
*/
val l = List(1,2,3)
l match {
case List(_,_,_) => println("list")
case _ => println("something else")
}
/**
* 6.元组模式
*/
val t = (1,"alex",22)
t match {
case (_,_,_) => println("tuple")
case _ => println("something else")
}
/**
* 测试类型模式
*/
val s = "alex"
type_mode(s)
val m = Map(1->‘2‘,2->‘3‘)
type_mode(m)
val m1 = Map("alex" -> "name","Lily" -> "name1")
println(show(m1 get "alex"))
}
/**
* 1.通配符，符号：_ 可以匹配任何对象
*/
def catch_all(a:Int): Unit = {
a match {
case 1 => println(‘a‘)
case 2 => println(‘c‘)
case _ => println(‘_‘)
}
}
/**
* 2.常量模式:用常量去匹配，基本类型的常量和val或单例对象也可以被用作常量。
* @param x
*/
def describe(x:Any) ={
x match {
case 5 => "five"
case true => "truth"
case "hello" => "hi"
case Nil => "the empty list"
case _=> "something else"
}
}
/**
* 4.构造器模式
* @param p
*/
def Constructor_mode(p:people) = {
p match {
case people(_,_) => println("people")
case _ => println("any")
}
}
/**
* 7.类型模式
* @param x
*/
def type_mode(x:Any) = {
x match {
case s: String => println(s.length)
case m: Map[_,_] => println(m.size)
case _ => println("something else")
}
}
def show(x:Option[String]) = x match {
case Some(s) => s
case None => "?"
}
}
三：模式守卫
作用：主要是为了更精确的匹配模式，主要就是在匹配的时候加一些过滤条件。
代码示例：
package 样本类和模式匹配
/**
* @Author:Alex_lei
* @Description: 模式守卫，主要是为了更精确的匹配模式
*/
object Mode_guard {
def main(args: Array[String]): Unit = {
/**
* 测试模式守卫
*/
val a = -10
print("a = -10 :")
m(a)
val b = 10
print("b = 10 :")
m(b)
val s = "abc"
print("s = abc :")
m(s)
val t = "a"
print("t = a :")
m(t)
}
def m(x:Any) = x match {
case x:Int if x>0 => println("Int")
case x:String if x.length>2 => println("String")
case _ => println("Any")
}
}
四：Option类型
option类型的值只有两种形式，可以是Some(x)，其中x是实际值，也可以None对象，Some和None都是它的子类，都是使用final修饰，不能再有派生子类。
代码示例：
package 样本类和模式匹配
/**
* @Author:Alex_lei
* @Description: option类型的值只有两种形式，可以是Some(x)，其中x是实际值，也可以None对象
* Some和None都是它的子类，都是使用final修饰，不能再有派生子类
*/
object Option {
def main(args: Array[String]): Unit = {
val book = Map("Hadoop" -> 10,"Spark" -> 20,"Flink" -> 30,"Scala" -> 40)
val t = book.get("Hadoop") //Option[Int] = Some(10)返回值是Option[Int]类型
println(t)
/**
* 下面两个例子说明，当有返回值的时候，结果不会返回getOrElse的参数
* 当没有返回值的时候，结果就会返回getOrElse的参数
*/
val t1 = book.get("Hbase").getOrElse("No key") //No key
println(t1)
val t2 = book.get("Spark").getOrElse("yes") //20
println(t2)
}
}
五：封闭类
封闭类，使用sealed关键字，用于模式匹配，当我们用样本类来做模式匹配时，想让编译器帮助我们确保列出了所有的可能，我们需要将样本类的超类进行封闭。但是在进行模式匹配的时候，必须要在匹配的表达式后面加一个@unchecked注解，功能是对于随后的模式的穷举性检查将被抑制掉。否在会出现警告。
代码示例：
package 样本类和模式匹配
/**
* @Author:Alex_lei
* @Description: 封闭类，使用sealed关键字，用于模式匹配，当我们用
* 样本类来做模式匹配时，想让编译器帮助我们确保列出了所有
* 的可能，我们需要将样本类的超类进行封闭。
*/
object Sealed {
def main(args: Array[String]): Unit = {
val t = Number(2)
val res = describe(t)
println(res)
des(t)
desc(t)
}
/**
* Warning:(16, 33) match may not be exhaustive.
* It would fail on the following inputs: Binop(_, _, _), Unop(_, _)
* def describe(x:Expr):String = x match {
*
* 这样写，会出现警告，说还有两种可能性
*
* 解决方式可以有以下两种，分别为des函数和desc函数
* des函数主要是在加一个通配符
* desc函数是在要匹配的表达式后面加一个@unchecked注解，功能是对于随后的模式的穷举性检查将被抑制掉
*/
def describe(x:Expr):String = x match {
case Number(_) => "a number"
case Var(_) => "a string"
}
def des(x:Expr):String = x match {
case Number(_) => "a number"
case Var(_) => "a string"
case _ => throw new RuntimeException
}
def desc(x:Expr):String = (x: @unchecked) match {
case Number(_) => "a number"
case Var(_) => "a string"
}
}
/**
* 定义封闭类Expr
*/
sealed abstract class Expr
/**
* 定义四个样本类继承Expr
*
*/
case class Var(name:String) extends Expr
case class Number(num:Double) extends Expr
case class Unop(operator:String,args:Expr) extends Expr
case class Binop(operator:String,left:Expr,right: Expr) extends Expr
原文地址：https://www.cnblogs.com/lyr999736/p/11373274.html
时间： 2024-11-08 04:49:31