Scala基础（一）

目录

模式匹配

基本语法

匹配常量

匹配类型

匹配数组

匹配列表

匹配元组 

匹配样例类

元组

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)

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))

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)

需要进行类型判断时，可以使用前文所学的 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)
    }

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)
    }

 

匹配元组 

   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)
    }

匹配样例类

    //样例类
    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))

 

在里面加一条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))

 

元组

元组只有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)

 、

swap方法

 val tuple2 = Tuple2(2, 1)

    println(tuple2)
    println(tuple2.swap)

 

 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)
}

 引用隐式类

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

 传值

处置有三种方法：方法传值 、 隐式传值 、 默认值

优先级：方法传值 > 隐式传值 > 默认值

方法传值

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

  println(test(10)(100, "lisi"))

隐式传值

隐式定义也能被引入

  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"

 默认值

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