scala之高级使用总结

一.匹配模式

• 概述
  • 类比于 java 中的 switch…case，但比其要强大、灵活很多。
  • 旨在解决符合一定模式（值也是模式的一种）情况下的匹配与处理问题。
• 使用说明
  • 一个模式匹配包含了一系列备选项，每个都开始于关键字 case。 每个备选项都包含了一个模式及一到多个表达式。箭头符号**=>**隔 开了模式和表达式。
  • 选择器 match {备选项}，match 表达式通过以代码编写的先后次序尝试每个模式来完成计算，只要发现有一个匹配的 case，剩下的 case 不会继续匹配。

示例
同类型

  def main(args: Array[String]) {
    println(selfMatch("javase"))
  }

  def selfMatch(x: String): String = x match {
    case "javase" => "Java 开发标准版"
    case "javaee" => "Java 开发企业版"
    case _ => "其它 Java 版本 "
  }

不同类型

  def main(args: Array[String]) {
    println(selfMatch("one"))
    println(selfMatch(2))
    println(selfMatch("III"))
    println(selfMatch("five"))
  }

  def selfMatch(x: Any): Any = x match {
    case "one" => 1
    case 2 => "two"
    case "III" => "希腊数字 3"
    case _ => "其它不认识了"
  }

复杂表达式匹配示例

  def main(args: Array[String]) {
    println(selfMatch(1))
    println(selfMatch(10))
    println(selfMatch(22))
    println(selfMatch(78))
  }

  def selfMatch(x: Int): String = x match {
    case _ if x < 12 => "幼年"
    case _ if x < 18 => "未成年"
    case _ if x >= 18 && x < 60 => "成年"
    case _ => "已步入老年了!"
  }

类型模式匹配示例

  def main(args: Array[String]) {
    println(selfMatch(1))
    println(selfMatch("10"))
    println(selfMatch(new TestPatternMatch()))
    println(selfMatch(new Object()))
  }

  def selfMatch(x: Any): Any = x match {
    case _: Int => "传入的是整型"
    case _: String => "传入的是字符串"
    case _: TestPatternMatch => "传入的数据类型是TestPatternMatch"
    case _ => "不知道什么类型"
  }
  //定义一个空类,便于上边的类型模式匹配
  class TestPatternMatch {

  }

二.正则表达式

• 概述
  • 与 Java 当中的正则表达式的作用完全相同
  • 用"".r 或是 scala.util.matching 包中的 Regex 类实现对正则的支持抽象。
• 常用方法
  • findAllIn：查找所有匹配结果
  • mkString：连接正则表达式匹配结果的字符串
  • 正则可以使用管道(|)来设置不同的模式

示例
   

//定义一个字符串作为正则表达式
    val pattern1 = "十八大".r
    //正则要去匹配的源字符串
    val str1 = "十八大是一个重要具有里程碑式的会议!"
    //在源串中查找第一个匹配 pattern 正则表达式的值
    println(pattern1 findFirstIn str1)//Some(十八大)


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

三.异常处理

• 概述
  • 异常处理机制与 Java 语言相似，其异常类也采用了 Java 类，并没有重写
  • 主要包括异常抛出和异常捕获两大方面。
  • 抛出异常用 throw，声明可能的异常与 Java 不同，采用的注解式的@throws(classOf[SomeException])
  • 捕获异常，采用的 try…catch 的模式匹配的形式
  • Scala 里不需要捕获检查异常：checked exception，也不是必须把它们声明在 throws 子句中。 可以用@throws 标注声明一个 throws 子句，但这不是必需的 该机制最大的问题是如果遇到异常没有补捉，则程序会终止，如果进行了捕捉，可以按照程序设定的方式去进行，而不必须停止。

示例

//方法内抛出异常
def f(){
    throw new Exception("测试异常抛出!");
}
//方法定义时声明要抛出异常
@throws(classOf[Exception])
def callMe() = {
    println("i am in callMe method") 
}
//捕获异常
try {
  val f = new FileReader("input.txt")
} catch {
  case ex: FileNotFoundException => {
    println("不好意思，文件没有找到!")
  }
  case ex: IOException => {
    println("不明原因的 IO 异常!")
  }
} finally {
  println("无论 try...catch 如何，都会执行 finally,我在finally 中!")
}

四.提取器

• 概述
  • 提取器是从传递给它的对象中提取出构造该对象的参数。
  • 提取器是一个带有 unapply 方法的对象。unapply 方法算是 apply方法的反向操作：unapply 接受一个对象，然后从对象中提取值，提取的值通常是用来构造该对象的值。
  • apply 与 unapply 方法是互反的，apply 用于构造一个对象，而不 需要用 new 方法是其重要特点，unapply 是反向解开这个对象，将其对应的参数值提取出来。

示例
 

 def main(args: Array[String]) {
    var obj = apply("antg", "192.168.1.33");
    println("Apply 方法形成一个对象: " + obj);
    println("Unapply 方法反向提取该对象中的参数:" +
      unapply(obj));
    println("Unapply 方法反向提取该对象中的参数: " +
      unapply("我不是一个登陆地址"));
  }

  // 注入方法 (可选)
  def apply(username: String, ip: String) = {
    username + "@" + ip
  }

  // 提取方法（必选）
  def unapply(str: String): Option[(String, String)] = {
    val parts = str split "@"
    if (parts.length == 2) {
      Some(parts(0), parts(1))
    } else {
      None
    }
  }

提取器与模式匹配

  def main(args: Array[String]) {
    //自动调用 TestUnapplyPatternMatch 的 apply 方法
    val loginInfo = TestFunction("antg", "192.168.1.33")
    println(loginInfo)
    loginInfo match {
      //unapply 被自动调用
      case TestFunction(username, ip) => println(username + "登陆了" + ip + " 这台机器！")
      case _ => println(loginInfo)
    }
  }

  def apply(username: String, ip: String) = username + "@" + ip

  def unapply(loginInfo: String): Option[(String, String)] = {
    val parts = loginInfo split "@"
    if (parts.length == 2) {
      Some(parts(0), parts(1))
    } else {
      None
    }
  }

五.文件IO

• 概述
  • 与java的基本类似
  • 其文件写操作，直接用的都是 java 中 的 I/O 类
  • 增加了少部分新 IO 类，并对 API 中做了部分简化

示例
写字符串到指定文件中

  def main(args: Array[String]) {
    val writer = new FileOutputStream(new File("output.txt"))
    writer.write("antg".getBytes("utf-8"))
    writer.close()
    println("done") 
  }

从控制台读取用户输入

  def main(args: Array[String]) {
    print("想对现在的自己说的话: ")
    var line = "";
    //scala支持在代码块中引入包
    import scala.util.control.Breaks._
    var br = new BufferedReader(new InputStreamReader(System.in, "utf-8"))
    //要使用break的话必须使用breakable包起来
    breakable {
      line = br.readLine()
      while (line != null) {
        if (line equals "exit") {
          break
        }
        println(line)
        line = br.readLine()
      }
    }
    br.close()
    println("done")
  }

从文件中读取内容

def main(args: Array[String]) {
    println("读取文件内容为:")
    println("第一种方式---------")
    var fileSource = Source.fromFile("output.txt", "utf-8")
    for (line <- fileSource.getLines) {
      println(line)
    }
    println("第二种方式---------")
    Source.fromFile("output.txt", "utf-8").foreach {
      print _
    }
    println("第三种方式---------")
    fileSource = Source.fromFile("output.txt", "utf-8")
    fileSource.foreach(print)
  }