Scala基础（一）

我就是我 2024-03-26 00:33 88阅读 0赞

**目录**

模式匹配

基本语法

匹配常量

匹配类型

匹配数组

匹配列表

匹配元组

匹配样例类

元组

swap方法

隐式转换

类型转换

引用隐式类

传值

方法传值

隐式传值

--------------------

## 模式匹配 ##

### 基本语法 ###

模式匹配语法中，采用 match 关键字声明，每个分支采用 case 关键字进行声明，当需要匹配时，会从第一个 case 分支开始，如果匹配成功，那么执行对应的逻辑代码，如果匹配不成功，继续执行下一个分支进行判断。如果所有 case 都不匹配，那么会执行 case \_分支，类似于 Java 中 default 语句

val x:Int =2
        val y:String =x match {
          case 1 =>"one"
          case 2 =>"two"
          case 3 =>"three"
          case _ =>"other"
        }
        println(y)

![5d7784a1611446059d4c0bc61d589c2d.png][]

> **TIP：**
> 
> （1）如果所有 case 都不匹配，那么会执行 case \_ 分支，类似于 Java 中 default 语句，若此时没有 case \_ 分支，那么会抛出 MatchError。  
> （2）每个 case 中，不需要使用 break 语句，自动中断 case。  
> （3）match case 语句可以匹配任何类型，而不只是字面量。  
> （4）=> 后面的代码块，直到下一个 case 语句之前的代码是作为一个整体执行，可以使用\{\}括起来，也可以不括。

### 匹配常量 ###

def match1(x:Int):String={
        x match {
          case 1 => "one"
          case 2 => "two"
          case _ => "many"
        }
      }
    
      println(match1(1))
      println(match1(3))

![b0ccceb8f2df4ab5ab208b118b11d5d5.png][]

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

### 匹配类型 ###

def match2(x: Any): Unit = {
          x match {
            case 1 => println("内容为1")
            case a: Int => println("内容类型为整型，值为：" + a)
            case s: String => println("内容类型为整型，内容为：" + s)
            case _ => println("不知道这是啥")
          }
        }
        match2(1)
        match2(2)
        match2("你好")
        match2(1.1)

![6aa080cf0a2c4e37a57f4f561d12878a.png][]

> 需要进行类型判断时，可以使用前文所学的 isInstanceOf\[T\]和 asInstanceOf\[T\]，也可使 用模式匹配实现同样的功能。
> 
> 返回1，不返回“内容类型为整型，值为：1”因为case首先查询第一个case，然后直接返回，不再进行下面的case

### 匹配数组 ###

for (arr <-List(
          Array(0),
          Array(1,0),
          Array(0,1,0),
          Array(4,8,9,23),
          Array("hello",20,30),
        )){
          val result =arr match {
            case Array(0) =>"0"
            case Array(1,0) =>"Array(1,0)"
            case Array(x,y) =>"Array:"+ x +" ," + y //匹配两元素数组
            case Array(0,_*) =>"以0开头的数组"
            case Array(x,1,z) =>"中间为1的三元数组"
            case _ =>"something else"
          }
          println(result)
        }

![a15555b3e5f6421bb8b3f24c20c2ab1a.png][]

> scala 模式匹配可以对集合进行精确的匹配，例如匹配只有两个元素的、且第一个元素为 0 的数组

### 匹配列表 ###

for (list <- List(
          List(0),
          List(1, 0),
          List(0, 0, 0),
          List(1, 1, 0),
          List(88),
          List("hello")
        )) {
          val result = list match {
            case List(0) => "0"
            case List(x, y) => "List(x,y):" + x + "," + y
            case List(0, _*) => "List(0,....)"
            case List(a) => "List(a):" + a
            case _ => "something else"
          }
          println(result)
        }

![6ef474eb99d947bcb630f3c9ec7dccc6.png][]

### 匹配元组 ###

for (tuple <- List(
          (0, 1),
          (0, 0),
          (0, 1, 0),
          (0, 1, 1),
          (1, 23, 65),
          ("hello", "scala", 111)
        )) {
          val result = tuple match {
            case (a, b) => "" + a + "," + b
            case (0, _) => "(0,_)"
            case (a, 1, _) => "(a,1,_)" + a
            case _ => "something else"
          }
          println(result)
        }

![d8258b7c034a42ecb2a54dbde853056d.png][]

### 匹配样例类 ###

//样例类
        case class Teacher(name: String, age: Int)
    
        def match3(teacher: Teacher): Unit = {
          teacher match {
            case Teacher("zs", 18) => println("hello")
            case Teacher("ls", 10) => println("你好")
            case x: Teacher => println("hello " + x.name)
          }
        }
        match3(Teacher("zs", 18))
        match3(Teacher("ww", 18))

![7a2bcc4733734ba7bb6b26d0f4ce0953.png][]

在里面加一条if语句

//样例类
        case class Teacher(name: String, age: Int)
    
        def match3(teacher: Teacher): Unit = {
          teacher match {
            case Teacher("zs", 18) => println("hello")
            case Teacher("ls", 10) => println("你好")
            case Teacher(name, age) if name == "zl" => println("卷王")
            case x: Teacher => println("hello " + x.name)
          }
        }
        match3(Teacher("zl", 17))

![5f157ccf5c494be8a38a048063f5f6e7.png][]

## 元组 ##

**元组只有22个,但可以套娃**

val tuple = Tuple3("hello",1,true)
    println(tuple._2)

val tuple22 = Tuple22(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22)
        println(tuple22._11)

![df675611550342d692c8d0a8cf86c217.png][]、

### swap方法 ###

val tuple2 = Tuple2(2, 1)
    
        println(tuple2)
        println(tuple2.swap)

### ![cbab3fcccd5942a78a02ff7dd1a7d770.png][] ###

> swap方法只有tuple2里面有，这个方法时交换两个元素位置

## 隐式转换 ##

### 类型转换 ###

object test {
      def main(args: Array[String]): Unit = {
      }
      implicit def stringToInt(value: String): Int = Integer.parseInt(value)
      implicit def stringToInt(value: Int): String = value.toString
      val a: Int = "111"
      val s: String = 10;
      println(a + 4)
      println(a + s)
    }

![5a16dce42b2a463e9e7b706c02e09827.png][]

### 引用隐式类 ###

在使用隐式类的时候必须要先导入这个文件

![745e4956e3084863a9669b9d39a48220.png][]

### 传值 ###

> 处置有三种方法：方法传值 、 隐式传值 、 默认值
> 
> 优先级：方法传值 > 隐式传值 > 默认值

#### 方法传值 ####

def test(a: Int)(implicit b: Int = 25, name: String): Int = {
        println(name)
        a + b
      }
    
      println(test(10)(100, "lisi"))

![cd94f7639e874b1091cd01cbb2e6d335.png][]

#### 隐式传值 ####

隐式定义也能被引入

def test(a: Int)(implicit b: Int = 25, name: String): Int = {
        println(name)
        a + b
      }
    
      println(test(10))

写在隐式类的包里的内容

implicit val num1: Int = 21
      implicit val name: String = "zss"

![d5682db51675474790785125514f32e7.png][]

默认值

def test(a:Int)(implicit b:Int = 25,name:String):Int ={
          println(name)
          a+b
        }
        println(test(10))

![61b0bd6b42ed45bd9834c1b4d426348e.png][]

[5d7784a1611446059d4c0bc61d589c2d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/64ba4bb573164fde9fc6716558080cef.png
[b0ccceb8f2df4ab5ab208b118b11d5d5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/8070652361c74ea680f84bf9b1ceaacd.png
[6aa080cf0a2c4e37a57f4f561d12878a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/1ccf181c944b4475a024da4f98e8af2c.png
[a15555b3e5f6421bb8b3f24c20c2ab1a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/72821ec23dad4e7f979cc9bc1f286c30.png
[6ef474eb99d947bcb630f3c9ec7dccc6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/8fcddcf0389e4ce1a49d91f711d023f9.png
[d8258b7c034a42ecb2a54dbde853056d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/9430abc11b014ce28a6d3eec30fd3643.png
[7a2bcc4733734ba7bb6b26d0f4ce0953.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/bdb1a6a302864a0f8d5cb5e7d5918c28.png
[5f157ccf5c494be8a38a048063f5f6e7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/12c00fb1fe864f2ca410b107f6727a7c.png
[df675611550342d692c8d0a8cf86c217.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/69b2b53c4bd242fea0fc184d92bc2418.png
[cbab3fcccd5942a78a02ff7dd1a7d770.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/2560885ca764421a8d833e0df2d1fbb0.png
[5a16dce42b2a463e9e7b706c02e09827.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/0f9841e1c8ef4d13bd36d65d1a0f90c5.png
[745e4956e3084863a9669b9d39a48220.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/c9f53c5932df4ed185da5ee4823f2e13.png
[cd94f7639e874b1091cd01cbb2e6d335.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/dc9bab93084144e8a6f44eac90f5a1db.png
[d5682db51675474790785125514f32e7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/8b4551eacd8c4dd3b2a76da7e342bffb.png
[61b0bd6b42ed45bd9834c1b4d426348e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/4d47f24c083a481c97b956b92426a9da.png