scala- 模式匹配

scala- 模式匹配

模式匹配

scala 中的 match（代替 java 中的 switch ,但更加强大）

• 语法格式

• 需要匹配的对象 match{
  case 值1 => 匹配成功操作
  case 值2 => 匹配成功操作
  case _ => 如果上面的都没有匹配 执行当前操作（相当于 default ）
  }

• match 表达式通过以代码编写的先后次序尝试每个模式来完成计算，只要发现有一个匹配的case，剩下的case不会继续匹配。

值匹配

	var sign = 0
    val ch = 'c'
    ch match {
      case 'a' => sign = 1
      case 'b' => sign = 2
      case _ => sign = 3
    }
    println(sign)
    // 3

集合中元素匹配

//集合匹配
    for (ch <- "xy23!") {
      var sign = 0
      ch match {
        case 'x' => sign = 1
        case 'y' => sign = 2
        // 加入守卫
        case _ if Character.isDigit(ch) => sign = Character.digit(ch, 10)
        case _ => sign = 9
      }
      print(sign + "\t")
    }
    //1	2	2	3	9

添加临时变量

//利用下标迭代
    val str = "+-3!"
    for (i <- str.indices) {
      var sign = 0
      var digit = 0

      str(i) match {
        case '+' => sign = 1
        case '-' => sign = -1
          //添加临时变量,此时ch1=str(i)
        case ch1 if Character.isDigit(ch1) => digit = Character.digit(ch1, 10)
        case _ =>
      }

      println(str(i) + " " + sign + " " + digit)
    }
  }

匹配类型

• 需求
  如果是int +1
  如果是String *2
  如果是Double +3

val list: List[Any] = List(1, '2', 3.0, "4")
    for (i <- list) {
      var res = i match {
        case i: Int => i + 1
        case i: String => i * 2
        case i: Double => i + 3
        case _ => 0
      }
      print(res + "\t")
    }
    //2	0	6.0	44

数组匹配

for (arr <- Array(
      Array(2, 3),
      Array(0),
      Array(1, 0),
      Array(0, 1, 0),
      Array(1, 1, 0),
      Array(3)
    )) {
      val result = arr match {
        //代表数组中有且仅有三个元素可以匹配到,可以重复
        case Array(a, b, c) => a + b + c
        //代表1开头的数组可以匹配
        case Array(1, _*) => "1 ..."
        //同第一条
        case Array(x, y) => x + " " + y
        //同第二条
        case Array(0, _*) => "0 ..."
        case Array(0) => "0"
        //代表其他
        case _ => "something else"
      }
      println(result)
      /*
      2 3
      0 ...
      1 ...
      1
      2
      something else
      */
    }

元组匹配

for (arr <- Array(
      (0, 1),
      (1, 0),
      (2, 0),
      (1, 1)
    )) {
      var res = arr match {
      	// _ 充当占位符  或者理解成匹配任意元素
        case (0, _) => "0 ..."
        case (y, 0) => y + " " + 0
        case _ => "other"
      }
      print(res + "\n")
    }
     /*
        0 ...
        1 0
        2 0
        other
      */

集合匹配

for (lst <- Array(
      List(0),
      List(1, 0),
      List(2, 3),
      List(0, 0, 0), //  List(0, 0, 0)=0 :: List(0,0)
      List(0, 'a', "b"),
      List(1, 0, 0)
    )) {
      val result = lst match {
        //匹配以0开始,空集合结束,即集合中只有0
        case 0 :: Nil => "0"
        //匹配有两个元素,空集合结束
        case x :: y :: Nil => x + " " + y
        //匹配以0开始,后面不限,xxx变量名任意
        case 0 :: xxx => xxx
        case _ => "something else"
      }
           println(result)
    }
     /*
        0
        1 0
        2 3
        List(0, 0)
        List(a, b)
        something else
      */