Scala的模式匹配和正则表达式

Scala的模式匹配

1. 模式匹配类似于switch case的含义
2. 模式匹配作用于方法或函数上
3. 模式匹配作用于类上–>样例类

• 模式匹配可以匹配固定类型的参数

match和case之间联合使用

case 1 => "one" 表示匹配为1，就返回one

def matchStr(x : Int):String = x match {
    case 1 => "one"
    case 2 => "TWO"
    case _ => "more"
  }

• 匹配任意类型的数据

def matchAny(x : Any):Any = x match {
case "A" => "A"
case 'F' => 'F'
case false => false
case 4L => 4L
case 3D => 3D
case _ => None
  }

• 匹配类对象

case class Person 表示定义一个样例类

def matchSample(): Unit ={
val pList = List(new Person("lzl","男"),new Person("hhh","男"),new Person("ggg","女"),new Person("mmm","女"))
for (p <- pList){
      p match {
case Person("lzl","男") => println("hi lzl!")
case Person("hhh","男") => println("hi hhh!")
case Person("ggg","女") => println("hi ggg!")
case Person("mmm","女") => println("hi mmm!")
case _ => print("hi None!")
      }
    }
  }

/**
 * 样例类
 * @param name
 * @param sex
 */
case class Person(name:String,sex:String)

Scala的正则表达式

Scala 的正则表达式继承了 Java 的语法规则，Java 则大部分使用了 Perl 语言的规则

• 一个实例

"scala".r创建出Regex类
pattern findFirstIn str 或者 pattern.findFirstIn(str) 方式调用findFirstIn方法

def patternStr(): Unit ={
    //创建一个Regex类
    val pattern = "scala".r
    val str = "scala is ok,scala to spark"
    println("正则表达式一:" + (pattern findFirstIn  str))
    println("正则表达式二:" + pattern.findFirstIn(str))
    println("正则表达式三:" + pattern.findAllIn(str).mkString(","))

    //匹配大小写开头的`java`
    val pt = "(J|j)ava".r
    val s = "Java is ok,java to spark"
    println("正则表达式四:" + pt.replaceAllIn(s,"scala"))
  }

scala的异常处理

1. scala的异常处理与java中是类似的，当抛出异常后，会终止程序的执行
2. scala中的异常处理使用模式匹配的思想来匹配异常类型的

• 直接抛出一个异常

def throwException = throw new IllegalArgumentException

• 模式匹配创建捕获异常

与java类似，finally是一定会执行的

def getFile(path : String): Unit ={
import java.io._
try{
      val file = new FileReader(path)
    }catch {
      case ex: FileNotFoundException =>{
        println("抛出FileNotFoundException异常 " + ex)
      }
      case ex : IOException =>{
        println("抛出IOException异常" + ex)
      }
    }finally {
      println("exit...")
    }

  }

Scala的提取器

1. apply类似于java类的构造方法，在伴生对象中可以创建不同的apply
2. unapply接收一个对象，在对象中提取相应的值

• 写一个伴生对象，并提供apply方法.

object MyExtractor{
def main(args: Array[String]): Unit = {
val x = MyExtractor(8)
    x match {
case MyExtractor(x) => println("x = " + x)
case _ => println("返回为空")
    }
  }

def apply(x : Int) = x * 3

def unapply(arg: Int): Option[Int] = {
if (arg % 2 == 0){
      Some(arg)
    }else{
      None
    }
  }