码迷，mamicode.com
首页 > 其他好文 > 详细

标准库

时间：2019-08-25 20:13:09      阅读：109      评论：0      收藏：0      [点我收藏+]

标签：atm   imp   png   ref   instance   ase   泛型   list   comm   

原文引用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}")

标准库

标签：atm   imp   png   ref   instance   ase   泛型   list   comm   

原文地址：https://www.cnblogs.com/petewell/p/11408868.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！