一、模式匹配

  • 类比与Java中的switch…case，但是比其强大并且灵活很多
  • 解决符合一定情况下的处理问题

  • 只要匹配到一个case，剩下的就不会匹配

    1. def main(args: Array[String]): Unit = {
    2.   //match...case
    3.   println(testMatch("java1"))
    4.   println(testMatch2(2))
    5.   println(testMatch3(78))
    6.   println(testMatch4(78.0))
    7. }
    8. //普通的一个match...case匹配
    9. def testMatch(str:String):String={
    10.   str match{
    11.     case "java1"=>"这是Java1"
    12.     case "java2"=>"这是Java2"
    13.     case "java3"=>"这是Java3"
    14.   }
    15. }
    16. //多种类型的match...case匹配
    17. def testMatch2(i:Any):String={
    18.   i match {
    19.     case "a"=>"这是字符串"
    20.     case 1 =>"这是数字类型"
    21.     case _ =>"这是未知"
    22.   }
    23. }
    24. //复杂类型的match...case匹配
    25. def testMatch3(i:Int):String={
    26.   i match {
    27.     case _ if i<18 =>"您未成年"
    28.     case _ if i>=18&&i<=60 =>"您成年了"
    29.     case _ if i>60 =>"您老年了"
    30.   }
    31. }
    32. //类型匹配的match...case匹配
    33. def testMatch4(i:Any):String={
    34.   i match {
    35.     case _:Int => "这是Int类型"
    36.     case _:String => "这是字符串类型"
    37.     case _:Double => "这是浮点数类型"
    38.     case _ => "这是未知类型"
    39.   }
    40. }

    二、正则表达式

  • 与Java中的正则表达式作用完全相同

  • 通常被用来验证、检索、替换那些符合某个模式(规则)的文本
  • 用 “ “ .r 或者Scala.uiil.matching中的Regex类实现对正则的抽象
  • findAllIn：查找所有匹配结果
  • mkString：连接匹配结果的字符串

  • 正则可以使用管道符 | 指定不同的模式 ```scala var str = “(十八|18)大”.r var teststr = “十八大是一个重要具有里程碑式的会议,18 大以来社会各届取得了显著的进展和成果!” println(str findAllIn teststr.mkString)

    val pattern = new Regex(“(十八|18)大”) //正则要去匹配的源字符串 val str = “十八大是一个重要具有里程碑式的会议,18 大以来社会各届取得了显著的进展和成果!” //在源串中查找所有匹配 pattern 正则表达式的值 println((pattern findAllIn str).mkString(“,”))

  1. //定义一个字符串作为正则表达式
  2. val pattern = new Regex("[\\d]+")
  3. //正则要去匹配的源字符串
  4. val str = "十八大是一个重要具有里程碑式的会议,18 大以来会各届取得了显著的进展和成果,影响中国 21 世纪发展的重要会议!"
  5. //在源串中查找第一个匹配 pattern 正则表达式的值
  6. println((pattern.findAllIn(str)).mkString(","))
  1. <a name="DEBWB"></a>
  2. # 三、异常处理
  4. - 与Java相似，异常类也采取了Java的异常类，并没有重写
  5. - 主要包括异常抛出和异常捕捉两大类
  6. - 抛出异常用 throw，声明可能的异常与 Java 不同，采用的注解式的@throws(classOf[SomeException]) 
  7. - 异常捕获采用try...catch
  8. - Scala 里不需要捕获检查异常：checked exception，也不是必须把它们声明在 throws 子句中。@throws 标注声明一个 throws 子句，但这不是必需的该机制最大的问题是如果遇到异常没有补捉，则程序会终止，如果进行了捕捉，可以按照程序设定的方式去进行，而不必须停止。 
  9. ```scala
  10.   //捕获异常
  11.   def main(args: Array[String]): Unit = {
  12.     try{
  13.       var f = new FileReader("input.txt")
  14.     }catch {
  15.       case ex: FileNotFoundException=>{
  16.         println("没有找到")
  17.       }
  18.       case ex: IOException => {
  19.         println("不明原因的 IO 异常!") }
  21.     }
  22.   }

四、提取器

  • 提取器的含义就时从传递给他的对象中提取出构造函数时的参数
  • 提取器是一个带有unapply方法的对象，从对象中提取值

  • apply和unapply时相反的

    1. //提取器
    2. def main(args: Array[String]): Unit = {
    3.   var str1 = apply("张三","21")
    4.   println(unApply(str1))
    5. }
    6. def apply(name:String,age:String):String={
    7.   return name +"-"+ age
    8. }
    9. def unApply(i:String):Option[(String,String)]={
    10.   var tempStr = i split("-")
    11.   if (tempStr.length==2){
    12.     return Some(tempStr(0),tempStr(1))
    13.   }else{
    14.     None
    15.   }
    16. }

    五、文件I/O

  • 与Java基本相似

    1. //从文件中读取文件
    2. def main(args: Array[String]): Unit = {
    3. println("第一种方法")
    4. var test1 = Source.fromFile("output.txt")
    5. for (temp<-test1.getLines()){
    6.   println(temp)
    7. }
    8. println("第二种方法")
    9. Source.fromFile("output.txt").foreach(print _)
    10. println("第三种方法")
    11. var test2 = Source.fromFile("output.txt")
    12. test2.foreach(print _)
    13. }