scala模式匹配和正则表达式

匹配字面量和常量

    在actor间传递消息，通常用的是string字面量、数字或是元组。如果消息是字面量，只需要输入想匹配的字面量即可。

def activity(day : String) = {  day match {    case "monday" => print("work hard")    case "sunday" => print("eating sleeping ")    case "friday" => print("read a good book")    case "saturday" => print("met with friends")  }}List("monday", "sunday", "friday", "saturday").foreach {activity}

    match是一个队Any起作用的表达式。它会对目标执行模式匹配，根据匹配模式的值调用合适的case表达式。字面量和常量可以直接匹配。字面量可以是不同的类型。match并不关心。

匹配通配符

    如果有一个值，与case表达式里的任何一个都不匹配，会得到一个MatchError异常。通配符可以避免抛出异常。

private object WeekDay extends Enumeration {  val monday =  Value("monday")  val sunday =  Value("sunday")  val tuesday =  Value("tuesday")  }def activity(day : WeekDay.Value) = {   day  match {     case WeekDay.monday => println()     case WeekDay.sunday => println()     case WeekDay.tuesday => println()     case _ => println("error")//通配符_，匹配剩下的日期   }}

匹配元素和列表

   元组和列表也可以用case表达式匹配。

def activity (input:Any) = {  input match {    case (a, b)/*匹配元组*/ => println()    case "done"/*匹配字面量*/ => println()    case _ => null  }} 

    匹配List可以用匹配元组的方式匹配，仅仅提供关心的元素即可，上下的元素可以通过数组展开符号(_*)略去。

def processItem(items: List[String]) = {  items match {    case List("apple", "ibm") => println("apple\tIbm")    case List("red", "blue", "white") => println("red\tlue\twhite")    //匹配两项或更多    case List("red", "blue", _*) => println("red\tlue...")    //匹配两项或更多，如果需要在后续的block中引用，可以定义变量，引用剩下的    case List("orange", "pear",otherfruits @ _*) =>println("red\tlue" + otherfruits)  }}

类型和卫述句的匹配

有时要处理的序列，其值可能是具有不同的类型。在scala中，case语句可以根据类型进行匹配。

def process(input:Any) = {  input match {    case (a:Int,b:Int) => {}    case (a:Double,b:Double) => {}    case msg : Int if (msg > 10000) => println("process input > 10000")    case msg : Int if (msg < 10000) => println("process input < 10000")    case _ => println("cannot hand anything")  }}

case表达式里的模式变量和常量

    上例中，为匹配的val定义占位符（比如匹配元组的a和b）这就是模式变量。scala中的模式变量要以小写字母开头，常量以大写字母开头。

class MatchType {val max = 100val Min = 0def process(input:Int) = {    input match {    /*     * 编译错误，scala将会认为max是一个模式变量，在当前范围内存在     */    case max => println("match max")    /*可行*/    case this.max => println("match max")    case Min => println("match min")        case _ => println("cannot hand anything")  }}}

使用case类进行模式匹配

package com.fanshadoopabstract class Tradecase class Sell(stocksym:String, number:Int) extends Tradecase class Buy(stocksym:String, number:Int) extends Tradecase class Hedge(stocksym:String, number:Int) extends Tradeclass TradeProcessor {def process(stock:Trade) = {  stock match {    /*此处stockCoe，quality都是模式变量     * 如果股票代码和数量得到匹配，会存在模式变量中     * */    case Sell(stockCode, 1000) => println("selling stock:" + stockCode)    case Sell(stockCode, quaility) => println("selling stock:" + quaility)    case Buy(stockCode, quaility) if (quaility > 2000) =>                                println("buy stock:" + quaility)    case Buy(stockCode, quaility) => println("buy stock:" + quaility)  }}}

case类也可以使用通配符。

使用提取器进行匹配

    scala提取器，匹配任意模式，会从输入中提取出匹配的部分。

package com.fanshadoopobject symbol {   /*    * 接受要匹配的值，返回Boolean    * */   def unapply(symbol : String) = {     symbol == "IBM" || symbol == "GOOC"   }}object ReceiveStockPrice {   def unapply(input : String) : Option[(String, Double)] = {      try {        if (input contains ":") {           val fields = input split  ":"           Some(fields(0), fields(1).toDouble)        } else {          None        }      } catch {        case _ : NumberFormatException => None      }   }}object Extractor {    def process(input:String) = {      input match {        /*执行symbol()时，会自动把input传递给提取器的unapply方法         * 返回true时，执行相关的表达式         * */        case symbol() => println("look up stock price for "+ input)        /*         * 提取器ReceiveStockPrice将input传递给unapply方法         * symbol和price用于从unapply接受返回值         */        case ReceiveStockPrice(stock , price) =>              printf("Receive price %f for stock %s\n",price, stock)        case _ => println("invalid input " + input)      }}    def main(args:Array[String]) = {   process("IBM")   process("GOOC")   process("IBM:100")   process("ERR:12.34")}}

package com.fanshadoopobject symbol {   /*    * 接受要匹配的值，返回Boolean    * */   def unapply(symbol : String) = {     symbol == "IBM" || symbol == "GOOC"   }}object ReceiveStockPrice {   def unapply(input : String) : Option[(String, Double)] = {      try {        if (input contains ":") {           val fields = input split  ":"           Some(fields(0), fields(1).toDouble)        } else {          None        }      } catch {        case _ : NumberFormatException => None      }   }}object Extractor {    def process(input:String) = {      input match {        /*执行symbol()时，会自动把input传递给提取器的unapply方法         * 返回true时，执行相关的表达式         * */        case symbol() => println("look up stock price for "+ input)        /*         * 首先应用ReceiveStockPrice，成功的话返回一对结果         * 对第一个结果进一步用symbol()提取器提取股票         */        case ReceiveStockPrice(stock @ symbol(), price) =>              printf("Receive price %f for stock %s\n",price, stock)        case _ => println("invalid input " + input)      }}    }

正则表达式

    scala.uti.matching包里的类支持正则表达式。

//r()方法返回一个Regex实例      val pattern = "(s|S)cala".r      val str = """scala is scalable cool tools"""      println(pattern.findAllMatchIn(str).mkString(", "))  

把正则表达式进行提取

    scala的正则表达式就是提取器。scala会把每个括号里的匹配都展开到一个模式变量里。比如"(S|s)cala".r有一个unapply()方法，它返回Option[String]。另一方面"(S|s)(cala)".r的unapply会返回Option[String,String]。

def process(input:String) = {          val MatchStock = """^(.+):(\d+\.?\d*)""".r      input match {        case MatchStock(stock, price) => printf("stock=%s,price=%f\n", stock,price)         case _ => println("invalid input " + input)      }}