scala笔记－模式匹配

 

1.scala是匹配和java中的switch的区别：                                                                                                   

• switch只能匹配值，模式匹配支持的更多，可以是任何类型（List，Map，Array，类型等都支持）
• 如果没有case匹配上会抛出异常，swicth会直接退出
• case _ 和 defalut 都是匹配其他默认case的
• 模式匹配中每个case结束不需要显示break，不会像swicth那样，会进入下一个分支
• match是表达式，可以赋值给变量，switch是语句，不能赋值给变量
• case语句支持守卫（任何boolean条件）
• case关键字后面可以跟着变量（此时匹配的表达式会复制给这个变量）

 

2.case 后可以跟着变量，也可以是常量

• 常量：大写字母开头或者 `小写字母开头`
• 变量：小写字母开头

 

3.case匹配类型，jvm类型擦除机制

• Array类型保存完整，可以匹配特定的Array［T］
• List，Map，Set，会被擦除类型，不能匹配特定类型T

测试代码：

package demo.scala

import java.io.File

import scala.util.Random

object App5 {

  val finalA = 'a'

  def main(args: Array[String]): Unit = {
    val array = Array("a", "b", "c")
    val name = array(Random.nextInt(array.length))

    //    matchType('a') //case _
    //    matchType(Set(1, 2)) //case f
    //    matchType(Set("1")) //case f
    //    matchType(List(1, 2)) //case c
    //    matchType(Array("a", "b"))

    // matchArray(Array("b1"))
    //    matchArray(Array("A"))
    //    matchArray(Array("a1", "a2"))
    //    matchArray(Array("a1", "a2", "a3", "a4"))
    //    matchArray(Array("b1", "a2", "a3", "a4", "a5"))

    //    matchList(List("A"))
    //    matchList(List("B1", "B2"))
    //    matchList(List("C"))
    //    matchList(List("C", "C2", "C3"))

    //    matchType(1)
    //    matchType("abc")
    //    matchType(List("a", "b"))
    //    matchType(List(1, 2))
    //    matchType(Map("k1" -> 1, "k2" -> 2))
    //    matchType(Map("k" -> "v"))


    //    testSwitch('a')
    //    testSwitch(File.pathSeparatorChar)

    //    matchTuple(Tuple2(1, 0))
    funcB()
  }

  def funcA(name: String, grade: String): Unit = {
    grade match {
      case "A" => println("A")
      case "B" => println("B")
      case _ if name == "lisi" => println("lisi")
      case _ => println("C")
    }
  }

  def funcB() = {
    val test = "10"
    var arr = new Array[Object](2)
    arr(0) = "10"
    arr(1) = "12"

    val Array(`test`, x) = arr
    println(Array(`test`, x).map(println(_)))

    val E = 10
    var array = Array(E, 11)
    var Array(E, y) = array
    println(Array(E, y)(0))
  }

  def matchArray(array: Array[String]) = {
    array match {
      case Array("A") => println("A")
      case Array(a, b) => println(a + "," + b)
      case Array("a1", _*) => println("C")

      case Array("b1", rest@_*) => {
        if (rest.length == 0)
          println("空")
      }
      case _ => println("_")
    }
  }

  def matchList(list: List[String]) = {
    list match {
      case "A" :: Nil => println("A") //只有一个元素A的list
      case x :: y :: Nil => println(list(0) + "," + list(1)) //包含两个元素的list， （x是第一个元素，y是第二个元素！！！）
      case "C" :: tail => println("C") //C是第一个元素的list
    }
  }

  def matchType(objet: Any) = {
    //scala中国match是表达式，不是语句，它可以赋值给变量，例如下面的rs变量
    var rs = objet match {
      case Char => println("char")
      case a: Int => println("int type") //返回（），因为是unit类型
      case b: String => "string type" //返回字符串
      case c: List[String] => println("list[String]")
      case d: Map[String, Int] => println("map[String,Int]")
      case e: Map[_, _] => println("map[_,_]")
      case f: Set[String] => println("f: set")
      case g: Array[Int] => println("g:Array[Int]")
      case _ => println("other")
    }

    //    println("rs = " + rs)
  }

  def testSwitch(str: Char): Unit = {
    str match {
      case _ => println("other")
      case `finalA` => println("case 2")
      case separatorChar => println("case 1")

    }
  }

  def matchTuple(pair: Tuple2[Int, Int]) = {

    pair match {
      case (_, 0) | (0, _) => println("ok") //有分支时，只能用下划线，不能用其他变量名
      //      case (b, 0) | (0, b) => println("fail") //会报错
    }
  }

}