模式匹配类型

 

 

object Test2_MatchTypes {
  def main(args: Array[String]): Unit = {
    //1、匹配常量
    def describeConst(x: Any): String = x match {
      case 1 => "Num one"
      case "hello" => "String"
      case true => "Boolean"
        //这个下划线是一个占位符，不是通配符
      case _ => "exit"
    }
    println(describeConst("hello"))
    println(describeConst(true))
    println(describeConst(111))
    println("-----------")

    //2、匹配类型
    def describeType(x: Any) = x match {
      case i: Int => "Int" + i
      case s: String => "String" + s
      case list: List[String] => "List: " + list
      case array: Array[Int] => "Array: " + array.mkString(",")
      case a => "exit" + a
    }

    println(describeType(2))
    println(describeType("scala"))
    println(describeType(List("hi", "hello")))
    //List存在泛型擦除，泛型就是 List[String] 中的String
    //所以能输出 List: List(1, 2)， Int类型的List
    println(describeType(List(1, 2)))
    println(describeType(Array(1, 3, 5)))
    println(describeType(Array("hi", "scala")))
    println("------------------")

    //3、匹配数组
    for (arr <- List(
      Array(0),
      Array(0, 2, 3),
      Array(11, 33),
      Array("hello", 2, 12)
    )) {
      val result = arr match {
        //case匹配之后会取走数据，所以后面不会再匹配取走的数据
        case Array(0) => "0"
        case Array(0, 2, 3) => "Array(0, 2, 3)"
        //匹配两个元素的数组
        case Array(x, y) => x + ", " + y
        case Array(0, _*) => "0开头的数组"
        case Array(x, 2, y) => "匹配中间为2的数组"
        case _ => "exit"
      }
      println(result)
    }
    println("-------------------")

      //4、匹配列表
      //5、方式一
      for ( list <- List(
        List(0),
        List(1, 0),
        List(0, 0, 0),
        List(1, 1, 0),
        List(33),
        List("hello")
      )) {
        val result = list match {
          case List(0) => "0"
          case List(x, y) => x + ", " + y
          case List(0, _*) => "0, ........"
          case List(a)  => a
          case _ => "exit"
        }
        println(result)
      }
    //方式二
    val list = List(1, 2, 4, 6, 7, 8)
    val list1 = List(1)
    list match {
      case first :: second :: rest => println(s"first: $first, second : $second, rest: $rest")
      case _ => println("exit")
    }

    list1 match {
      case first :: second :: rest => println(s"first: $first, second : $second, rest: $rest")
      case _ => println("exit!")
    }
    println("------------------------")

    //5、匹配元组
    for (tuple <- List(
      (0, 1),
      (0, 0),
      (0, 1, 1),
      (1, 1, 1),
      (1, 2, 3),
      ("hello", true, 0.3),
    )) {
      val result = tuple match {
        case (a, b) =>   " " + a + ", " + b
        case (0, _) => "第一个是0的二元组"
        case (a, 1, _) => "中间是1的, " + a
        case _ => "exit"
      }
      println(result)
    }
  }
}

 

 

 

 

元组匹配还有其他几种匹配方式:

 

object Test3_MatchTupleExtend {
  def main(args: Array[String]): Unit = {
    //1、在变量声明时，匹配
    val (x, y) = (1, true)
    println((x, y))

    //不用 :: 不能使用rest去赋值，只能用_*
    val List(first, second, _*) = List(1, 2, 3, 4, 5, 1)
    println((first, second))

    val fir :: sec :: rest = List(11, 22, 33 ,44 ,55)
    println((fir, sec, rest))
    println("------------------------")

    //2、for推导式中进行模式匹配
    val list = List(("a", 1), ("b", 2), ("c", 3), ("a", 5))

    //2.1原本的便利方式
    for  (elem <- list) {
      println(elem._1 + ", " + elem._2)
    }
    println("----------------")

    //2.2 将List元素直接定义为元组，对变量赋值
    for ((word, count) <-list) {
      println(word + " ," + count)
    }
    println("--------------------")

    //2.3 可以不考虑某个位置的变量，之遍历key或者value
    for ((word, _) <- list) println(word)
    println("---------------------")

    //2.4 指定某个位置的值必须是多少
    for (("a", count) <- list) println(count)
  }

}