scala模式匹配，元组

scala模式匹配类似于java中的switch语法

基本语法

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

def match(x:Int):String={
    x match {
      case 1=>"one"
      case 2=>"two"
      case _=>"other"
    }
  }
println(d)           //other

一，模式守卫

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

    println("===模式守卫============")
    def match(num:Int):Int ={
      num match {
        case i if i >= 0 => i
        case i if i < 0 => -i
      }
    }

    println(match2(90))        // 90
    println(match20(-34))      // 34

二，匹配常量

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

def match(x:Int):String={
    x match {
      case 1=>"one"
      case 2=>"two"
      case _=>"other"
    }
  }

println(1)   //one

三，匹配类型

需要进行类型判断时，可以使用前文所学的 isInstanceOf[T]和 asInstanceOf[T]，也可使 用模式匹配实现同样的功能。

def match(x:Any):Unit={
    x match {
      case 1=>println("内容为1")
      case a:Int=>println("内容类型为整型，值为："+a)
      case s:String=>println("这是一个字符串，内容为："+s)
      case _=>println("不知道是什么")
    }
  }

println(1)   //内容为1

四，匹配数组

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

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

五，匹配列表

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

七，匹配样例类

def match(teacher:Teacher):Unit={
    teacher match {
      case Teacher("zhangsan",39)=>println("hi zhangsan")
      case Teacher("lisi",18)=>println("hi lisi")
      case Teacher(name,age)if (name=="wangwu"&& age==45)=>println("优秀")
      case x:Teacher=>println("hello "+x.name)
    }
  }
  //样例类
  case  class Teacher(name:String,age:Int)

 match(Teacher("zhangsan",39))  //hi zhangsan

元组

元组只有22个；swap方法只有tuple2中才有，指交换两个元素的位置

val tuple: (String, Int, Boolean) = Tuple3("hello", 1, true)
    println(tuple)      //(hello,1,true)
    println(tuple._3)   //true

 val tuple1: (Int, String) = Tuple2(8, "name")
    println(tuple1.swap)  //(name,8)