正则
import scala.util.matching.Regex
import scala.util.matching.Regex.Match
/*
----------------------------------------------------------
匹配
*/
val rtr = "^(\\w+)@([a-z0-9]{2,})\\.(com|cn|edu|org)$";
val regex:Regex = rtr.r
// 同 Java 的简单匹配
val bool: Boolean = "12665473@qq.com".matches(rtr)
/*
----------------------------------------------------------
查找：模式匹配，对象提取：【元组，样例类】
*/
val tp3: (String, String, String) = "12665473@q.com" match {
case regex(g1, g2, g3) => (g1, g2, g3)
case _ => ("INVALID", "INVALID", "INVALID")
}
/*
----------------------------------------------------------
替换
*/
val rtr = "(8\\d+)"
val regex:Regex = rtr.r
val content = "java:88,mysql:80,scala:69,spark:75"
val replace1: String = regex.replaceFirstIn(content, "99")
// 参二为函数 f:Matcher=>Option[String]
val replace2: String = regex.replaceSomeIn(content, m => Some((m.group(1).toInt+10).toString))
val replace3: String = regex.replaceAllIn(content, "99")
// 参二为函数 f:Matcher=>String
val replace4: String = regex.replaceAllIn(content, m => (m.group(1).toInt+10).toString))
/*
----------------------------------------------------------
分组：必须添加 ()
*/
val regexPart = "\\d+".r
val cont = "112,334,453,229,4567"
val name: Option[String] = regexPart.findFirstIn(cont) // Some(112)
val it: Regex.MatchIterator = regexPart.findAllIn(cont) // 112 334 453 229 4567
Regex.Match match = regexXxx.findXxxMatchInt(content:String)
val groupContent = match.group(id:Int)
val rtr = "(\\w+):(\\d+)"
val regex:Regex = rtr.r
val content = "java:88,mysql:80,scala:69,spark:75"
val name: Regex.Match = regexPart.findFirstMatchIn(cont)
val matches: Iterator[Regex.Match] = regex.findAllMatchIn(content)
matches.foreach(m=>println(s"${m.group(1)} => ${m.group(2)}"))
/*
练习一：使用正则表达式解析日志
现有如下日志信息，请使用Scala正则表达式解析如下信息
日志级别
日期
请求URI
INFO 2016-07-25 requestURI:/c?app=0&p=1&did=18005472&industry=469&adid=31
INFO 2016-07-26 requestURI:/c?app=0&p=2&did=18005473&industry=472&adid=31
INFO 2016-07-27 requestURI:/c?app=0&p=1&did=18005474&industry=488&adid=32
*/
隐式类
/*
隐式转换
隐式参数：隐式传入
场景：多个函数共享同一个参数，选择柯里化，将最后一个列表设计为该共享参数的唯一参数，并将
该参数设置为 implicit
implicit order:Ordering[Int] = Ordering.Int.reverse
val sorted = Array(8,1,3,2,5).sorted(implicit order:Ording[Int])
隐式函数：隐式类型转换
implicit def strToInt(str:String) = str.toInt
val a:Int = "12"
隐式类：扩展
用implicit关键字修饰的类，扩展其主构造器唯一参数类型的功能
只能在类、Trait、对象（单例对象、包对象）内部定义
构造器只能携带一个非隐式参数
隐式类不能是 case class
在同一作用域内，不能有任何方法、成员或对象与隐式类同名
隐式类必须有主构造器且只有一个参数
*/
// 字符串的方法扩展，而在 Java 中 String 是final的，无法扩展
implicit class StrExt(str:String){
def incr() = str.map(c=>(c+1).toChar)
def isEmail = str.matches("\\w+@[a-z0-9]{2,10}\\.(com(.cn)?|cn|edu|org)")
}
val a:String = "12665473@qq.com"
val incr: String = a.incr
val isEmail: Boolean = a.isEmail
异常处理
/*
Exception : compiling : try...catch...
RuntimeTime : running : 用程序逻辑(分支结构)
外部资源：释放 finally : try(resource extends AutoClosable)
void close() throws Exception;
*/
try(
// 此处声明并初始化的 AutoCloseable 资源会在使用完自动释放
){
// 代码块(非异常代码不放)
}catch(Exception ex){
// 异常的捕获和处理
}
try{
// 代码块(非异常代码不放)
}catch(Exception ex){
// 异常的捕获和处理
}finally {
// 释放资源
}
// 同 Java
def divideThrow(a:Int,b:Int) = {
if(b==0){
throw new Exception("divide by zero")
}
a/b
}
// 同 Java + Optional
def divideTry(a:Int,b:Int):Option[Int] = {
try{
Some(a/b)
}catch {
case e:ArithmeticException => None
}
}
// scala 特有 Either[Left异常,Right正常]
def divideEither(a:Int,b:Int): Either[String,Int] = {
try{
Right(a/b)
}catch {
case e:ArithmeticException => Left("divide by zero")
}
}
// 案例
val e: Either[String, Int] = divideEither(1, 2)
val v = if(e.isLeft) e.left else e.right
// 【推荐】
import scala.util.control.Exception.{allCatch,failAsValue}
// Option[V] => Some(V) : None
// V v = if(opt.isEmpty) defaultValue else opt.get
def divideOpt(a:Int,b:Int) = {
allCatch.opt(a/b)
}
// Try[V] => Success(V) : Failure(Throwable)
def divideWithTry(a:Int,b:Int) = {
allCatch.withTry(a/b)
}
// Either[Throwable,V] => Right(V) : Left(Throwable)
def divideEither(a:Int,b:Int) = {
allCatch.either(a/b)
}
// 【推荐】参数1：异常类型，参数2：异常发生返回的值，参数3：正常返回的值
def divideFail(a:Int,b:Int) = {
failAsValue(classOf[ArithmeticException])(-1)(a/b)
}
类型信息处理
case class Text(author:String,title:String,price:Float)
class TextSon(level:String,
override val author:String,
override val title:String,
override val price:Float)
extends Text(author, title, price)
{
val _level:String = level
override def toString() = s"TextSon{${super.toString}, ${_level}}"
}
// 提取类型信息
val ci: Class[Text] = classOf[Text]
val obj:Text = new TextSon("TOP","The Wild Roaring","张培元",86.32f)
// 类型判断
val isIns: Boolean = obj.isInstanceOf[TextSon]
// 类型转换：转换不当会导致 ClassCastException
val son: TextSon = obj.asInstanceOf[TextSon]
val son: Option[TextSon] = allCatch.opt(obj.asInstanceOf[TextSon])
