标准库

时间:2019-08-25
本文章向大家介绍标准库，主要包括标准库使用实例、应用技巧、基本知识点总结和需要注意事项，具有一定的参考价值，需要的朋友可以参考一下。

原文引用https://www.dazhuanlan.com/2019/08/25/5d625be60af3d/


Scala Package

Any

1
2
3
4
5
6
 
class {
	
	def isInstanceOf[T]
	
	def asInstanceOf[T]
}
 
1
2
3
4
 
1.asInstanceOf[String]				// 报错，未定义隐式转换函数
1.isInstanceOf[String]				// `false`
List(1),isInstanceOf[List[String]]	// `true`，泛型类型擦除
List(1).asInstanceOf[List[String]]	// 成功，泛型类型擦除

Option

1
2
3
4
5
6
7
8
 
class Option[T]{
	// `Some`实例：返回被被包裹值
	// `None`实例：返回参数（默认值）
	def getOrElse(default?: T)
}

class Some[T](s?: T) extends Option[T]
object None extends Option[_] ???

  • 推荐使用Option类型表示可选值，明示该值可能为None

  • Option类型可以被迭代
    • Some(s)：唯一迭代s
    • None：空
    1
    2
    		 
    val a = Some("hello")
    a.foreach(x => println(x.length))

Predef

1
2
3
4
 
object Predef extends LowPriorityImplicits{
	// 返回运行过程中类型，具体实现由编译器填补
	def classOf[T]: Class[T] = null
}

List

collection

mutable

Map

1
2
3
4
 
val a=Map((3,4), 5->6)
// 两种创建`Map`、二元组形式等价
a.map{case (a, b) => println(a, b)}
// `{case...}`为偏函数（或`Function1`）

immutable

reflect

runtime

universe

  • universe：提供一套完整的反射操作，可以反思性的检查 类型关系，如：成员资格、子类型
1
2
 
// 返回类型`T`“类型值”，可以用于比较
typeOf[T]
TypeTag
  • TypeTag：提供编译时具体类型的信息
    • 能获取准确的类型信息，包括更高的泛型类型
    • 但无法获取运行时值的类型信息 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    		 
    import scala.reflect.runtime.universe.{TypeTag, TypeRef, typeTag}

    // 声明隐式参数列表
    def recognize[T](x: T)(implicit tag: TypeTag[T]): String =
    	tag.tpe match {
    		case TypeRef(utype, usymbol, args) =>
    			List(utype, usymbol, args).mkString("n")
    	}

    val list: List[Int] = List(1,2)
    val ret = recognize(list)

    // 显式实例化`TypeTag`
    val tag = typeTag[List[String]]
  • WeakTypeTag：提供编译时包括抽象类型的信息
    • WeakTypeTag可以视为TypeTag的超集
    • 若有类型标签可用于抽象类型，WeakTypeTag将使用该标记
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    		 
    import scala.reflect.runtime.universe.{WeakTypeTag, TypeRef, weakTypeRef}

    // 声明隐式参数列表
    def recognize[T](x: T)(implicit tag: WeakTypeTag[T]): String =
    	tag.tpe match {
    		case TypeRef(utype, usymbol, args) =>
    			List(utype, usymbol, args).mkString("n")
    	}
    abstract class SAClass[T]{
    	// 抽象类型
    	val list: List[T]
    	val result = Recognizer.recognize(list)
    	println(result)
    }
    new SAClass[Int] { val list = List(2,3)}

    // 显式实例化`WeakTypeTag`
    val tag = weakTypeTag[List[String]]

ClassTag

ClassTag：提供关于值的运行时信息

  • 不能在更高层次上区分，如：无法区分List[Int]、 List[String]
  • 是经典的老式类，为每个类型捆绑了单独实现，是标准的 类型模式
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
import scala.reflect.{ClassTag, classTag}

// def extract[T: ClassTag](list: List[Any]) =
def extract[T](list: List[Any])(implicit ct: ClassTag[T]) =
	list.flatMap{
		case element: T => Some(element)
		// 以上被翻译为如下，告诉编译器`T`的类型信息
		// case element @ ct(_: T) =>
		// 否则泛型`T`被删除，编译不会中断，但是无法正确工作
		case _ => None
	}

val list: List[Any] = List(1, "string1", List(), "string2")
val rets = extract[String](list)

// 显式实例化`ClassTag[String]`
val ct = classTag[String]
  • 当需要ClassTag[T]类型的隐式值ct时，编译器会自动创建
    • 也可以使用classTag显式实例化
  • ClassTag[T]类型值ct存在时，编译器将自动
    • 包装(_:T)类型模式为ct(_:T)
    • 将模式匹配中未经检查的类型测试模式转换为已检查类型

util

matching

Regex

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
import scala.util.matching.{Regex, Match}

class Regex(?pattern: String, ?group: String*){
	def findAllIn(source: CharSequence): MatchIterator
	def findAllMatchIn(source: CharSequence): Iterator[Match]
	def findFirstIn(source: CharSequence): Option[String]
	def findFirstMatchIn(source: CharSequence): Option[Match]
	def replaceAllIn(target: CharSequence, replacer: (Match) => String): String
	def replaceAllIn(target: CharSequence, replacement: String): String
	def replaceFirstIn(target: CharSequence, replacement: String): String
	// 此`unapplySeq`就应该是定义在类中
	def unapplySeq(target: Any): Option[List[String]] = target match{
		case s: CharSequence => {
			val m = pattern matcher s
			if (runMatcher(m)) Some((1 to m.groupCount).toList map m.group)
			else None
		}
		// 等价于重载
		case m: Match => unapplySeq(m.matched)
		case _ => None
	}
}

class Match{
	def group(?key: Int): String
	def group(?key: String): String
}
 
1
2
3
4
5
6
7
8
9
10
 
val keyValPattern: Regex = "([0-9a-zA-Z-#() ]+): ([0-9a-zA-Z-#() ]+)".r
// `String.r`可使任意字符串变成正则表达式
// 使用括号同时匹配多组正则表达式

val input: String =
"""backgroud-color: #A03300l
  |background-image: url(img/header100.png);""".stripMargin

for(patternMatch(attr, value) <- keyValPattern.findAllMatchIn(input))
	println(s"key: ${attr}, value: ${value}")

原文地址：https://www.cnblogs.com/petewell/p/11408868.html

随机文章
本站知识点必读
最近更新