kafka视频教程，Scala模式匹配

模式匹配的声明

---

（1）变量声明时匹配

（2）for表达式中匹配

package chapter08

object Test03_MatchTupleExtend {

def main(args: Array[String]): Unit = {

//在变量声明时候匹配

val (x, y) = (10,“hello”)

println(s"x: $x, y: $y ")

val List(first, second, rest) = List(23,24,25)

println(s"first: $first, second: $second, rest: $rest")

val List(fir, sec, _*) = List(23,24,25,26)

println(s"fir: $fir, sec: $sec")

val firs :: seco :: res = List(23,24,25,26)

println(s"fir: $fir, sec: $sec,rest:$res")

//for推导式中进行模式匹配

val list: List[(String,Int)] = List((“a”,1),(“b”,2),(“c”,3),(“a”,4))

//原本的遍历方式

for (elem <- list){

println(elem._1 + " " + elem._2)

}

//将List的元素定义为元组，对变量赋值

for ((word,count) <- list){

println(word + " " + count)

}

//不考虑某个位置的变量，只遍历key或value

for ((word,count) <- list){

println(word)

}

//指定某个位置的值必须是多少的遍历

for ((“a”,count) <- list){

println(count)

}

}

}

模式守卫

---

如果想要表达匹配某个范围的数据，就需要在模式匹配中增加条件守卫。

//模式守卫

//求一个整数的绝对值

def abs(num:Int): Int = {

num match {

case i if i >= 0 => i

case i if i <= 0 => -i

}

}

println(abs(78))

println(abs(-78))

模式匹配类型

---

匹配常量

Scala 中，模式匹配可以匹配所有的字面量，包括字符串，字符，数字，布尔值等等。

匹配类型

需要进行类型判断时，可以使用前文所学的 isInstanceOf[T]和 asInstanceOf[T]，也可使

用模式匹配实现同样的功能。

匹配集合

scala 模式匹配可以对集合进行精确的匹配。比如数组、列表、元组等。

package chapter08

object Test02_MathTypes {

def main(args: Array[String]): Unit = {

//匹配常量

def describeConst(x: Any): String = x match {

case 1 => “int one”

case “hello” => “string hello”

case true => “Boolean true”

case ‘+’ => “char +”

case _ => “other”

}

println(describeConst(“hello”))

println(describeConst(‘+’))

println(describeConst(0.3))

//类型匹配

def describeType(x: Any): String = x match {

case i: Int => "int "+i

case s: String => "string " + s

case list: List[String] => "List " + list

case array: Array[Int] => “Array[Int] " + array.mkString(”,")

case a => "something else: " + a

}

println(describeType(3))

println(describeType(“s”))

println(describeType(List(1,2)))

println(describeType(Array(1,2)))

println(describeType(List(“1,2”)))

//匹配数组

for(arr <- List(

Array(0),

Array(1,2,3),

Array(1,2,“hello”),

Array(1,2,15),

Array(1,2),

)){

val result = arr match {

case Array(0)=> “0”

case Array(1,2,3) => “Array(1,2,3)”

case Array(x,y) => "Array: " + x + ", " + y //匹配两元素数组

case Array(1,_*) => “以1开头的数组”

case Array(x, 2, y) => “中间为2的三元素数组”

case _ => “something else”

}

println(result)

}

//列表匹配

for(list <- List(

List(0),

List(0,1),

List(1,1,0),

List(1,1,1),

List(88),

)){

val result = list match {

case List(0) => “0”

case List(x,y) => “list(x + y)” + x +“,” + y

case List(1,_*) => “list(1,…)”

case List(a) => “list(a)” + a

case _ => “something else”

}

println(result)

}

//方式二

val list = List(1,2,3,45,12)

val list2 = List(1)

list2 match {

case first :: second :: rest => println(s"first: $first, second: $second, rest: $rest")

case _ => println(“something else”)

}

println(“============”)

//匹配元组

for (tuple <- List(

(0,1),

(1,2,3),

(0,1,2),

(“hello”,1),

)){

val reuslt = tuple match {

case (a,b) => “” + a + “,” +b

case (0,) => “（0，——）” //不可以(0，*)，因为元组的大小是固定好的

case (a, 1, _ ) => “()”

case _ => “something else”

}

println(reuslt)

}

}

}

匹配对象及样例类

---

匹配对象

案例实操

class User(val name: String, val age: Int)

object User{

def apply(name: String, age: Int): User = new User(name, age)

def unapply(user: User): Option[(String, Int)] = {

if (user == null)

None

else

Some(user.name, user.age)

}

}

object TestMatchUnapply {

def main(args: Array[String]): Unit = {

val user: User = User(“zhangsan”, 11)

val result = user match {

case User(“zhangsan”, 11) => “yes”

case _ => “no”

}

println(result)

}

}

说明

（1） val user = User(“zhangsan”,11)，该语句在执行时，实际调用的是 User 伴生对象中的apply 方法，因此不用 new 关键字就能构造出相应的对象。

（2） 当将 User(“zhangsan”, 11)写在 case 后时[case User(“zhangsan”, 11) => “yes”]，会默认调用 unapply 方法(对象提取器)，user 作为 unapply 方法的参数，unapply 方法

将 user 对象的 name 和 age 属性提取出来，与 User(“zhangsan”, 11)中的属性值进行

匹配

（2） case 中对象的 unapply 方法(提取器)返回 Some，且所有属性均一致，才算匹配成功,

属性不一致，或返回 None，则匹配失败。

（3） 若只提取对象的一个属性，则提取器为 unapply(obj:Obj):Option[T]

若提取对象的多个属性，则提取器为 unapply(obj:Obj):Option[(T1,T2,T3…)]

若提取对象的可变个属性，则提取器为 unapplySeq(obj:Obj):Option[Seq[T]]

样例类

基本介绍

（1）语法：

case class Person (name: String, age: Int) //举例

（2）说明

• 样例类仍然是类，和普通类相比，只是其自动生成了伴生对象，并且伴生对象中

自动提供了一些常用的方法，如 apply、unapply、toString、equals、hashCode 和 copy。

• 样例类是为模式匹配而优化的类，因为其默认提供了 unapply 方法，因此，样例

类可以直接使用模式匹配，而无需自己实现 unapply 方法。

• 构造器中的每一个参数都成为 val，除非它被显式地声明为 var（不建议这样做）

案例实操

上面的匹配对象的案例使用样例类会节省大量代码

case class User(name: String, age: Int)

object TestMatchUnapply {

def main(args: Array[String]): Unit = {

val user: User = User(“zhangsan”, 11)

val result = user match {

case User(“zhangsan”, 11) => “yes”

case _ => “no”

}

println(result)

}

}

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

最后

针对以上面试题，小编已经把面试题+答案整理好了

面试专题

除了以上面试题+答案，小编同时还整理了微服务相关的实战文档也可以分享给大家学习

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
unity.csdnimg.cn/images/e5c14a7895254671a72faed303032d36.jpg" alt=“img” style=“zoom: 33%;” />

最后

针对以上面试题，小编已经把面试题+答案整理好了

[外链图片转存中…(img-qKJMUVgA-1713459432455)]

[外链图片转存中…(img-tVKOns9M-1713459432456)]

[外链图片转存中…(img-UwQihNCw-1713459432457)]

面试专题

[外链图片转存中…(img-udwWQB1k-1713459432459)]

除了以上面试题+答案，小编同时还整理了微服务相关的实战文档也可以分享给大家学习

[外链图片转存中…(img-iUYgg7Rq-1713459432460)]

[外链图片转存中…(img-vLDFZ6Rf-1713459432465)]

[外链图片转存中…(img-V2DI0bBf-1713459432467)]
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！