Scala Extention

本文主要是介绍Scala Extention，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

正则

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 4567Regex.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正则表达式解析如下信息日志级别日期请求URIINFO 2016-07-25 requestURI:/c?app=0&p=1&did=18005472&industry=469&adid=31INFO 2016-07-26 requestURI:/c?app=0&p=2&did=18005473&industry=472&adid=31INFO 2016-07-27 requestURI:/c?app=0&p=1&did=18005474&industry=488&adid=32
*/

隐式类

/*隐式转换隐式参数：隐式传入场景：多个函数共享同一个参数，选择柯里化，将最后一个列表设计为该共享参数的唯一参数，并将该参数设置为 implicitimplicit order:Ordering[Int] = Ordering.Int.reverseval sorted = Array(8,1,3,2,5).sorted(implicit order:Ording[Int])隐式函数：隐式类型转换implicit def strToInt(str:String) = str.toIntval 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 = leveloverride 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])

这篇关于Scala Extention的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---