Scala教程(十四)Scala泛型及约束实战
Scala教程(十四)Scala泛型及约束实战
1 Scala泛型
1.1 泛型函数
ClassTag[T]保存了泛型擦除后的原始类型T,提供给被运行时的。
/*
* 泛型[]，中括号F、S、T都表示运行时参数类型，
* ClassTag[T]保存了泛型擦除后的原始类型T,提供给被运行时的。
*/
class Triple[F: ClassTag, S, T](val first: F, val second: S, val third: T)
object HelloTypeParam {
def main(args: Array[String]): Unit = {
// 运行执行代码：val triple: Triple[String, Int, Double]
val triple = new Triple("Spark", 3, 3.1415)
// 运行执行代码：val bigData: Triple[String, String, Char]
val bigData = new Triple[String, String, Char]("Spark", "Hadoop", 'R');
// getData函数传入泛型为T的运行时List类型参数，返回list.length / 2的整数。
def getData[T](list:List[T]) = list(list.length / 2)
// List索引从0开始，执行结果：Hadoop
println(getData(List("Spark","Hadoop",'R')));
// 获得getData函数引用
val f = getData[Int] _
// 调用getData函数，执行结果：4
println(f(List(1,2,3,4,5,6)));
}
}
1.2 类型变量界定
泛型参数类型限定，限定具体类的可以调用特定的方法。
/*
* <:泛型类型限定符，表示只限定Comparable子类
* Comparable[T]:为T下界，T:为Comparable[T]上界
*/
class Pair[T <: Comparable[T]](val first: T, val second: T) {
// compareTo方法进行比较，如果大于0返回first
def bigger = if (first.compareTo(second) > 0) first else second
}
// 声明带T泛型参数的类
class Pair_Lower_Bound[T](val first: T, val second: T) {
// 传入的参数泛型T 必须为 R的父类(超类),返回构造Pair_Lower_Bound对象
// R:为T的上界，T:为R下界
def replaceFirst[R>:T](newFirst:R) = new Pair_Lower_Bound[R](newFirst,second)
}
object TypeVariablesBounds {
def main(args: Array[String]): Unit = {
// 函数调用
var pair = new Pair("Spark", "Hadoop")
// 执行结果：Spark
println(pair.bigger)
}
}
1.3 泛型视图限定
泛型视图限定：表示把传入不是Comparable[T]类型的隐式传换为Comparable[T]类型，Comparable[T]:为T下界，T:为Comparable[T]上界。
/*
* <%泛型视图限定符，表示把传入不是Comparable[T]类型的 隐式传换 为Comparable[T]类型
* Comparable[T]:为T下界，T:为Comparable[T]上界
*/
class PairNotPerfect[T <% Comparable[T]](val first: T, val second: T) {
// compareTo方法进行比较，如果大于0返回first
def bigger = if (first.compareTo(second) > 0) first else second
}
/*
* <%泛型视图限定符，表示把传入不是Ordered[T]类型的 隐式传换 为Ordered[T]类型
* Ordered[T]:为T下界，T:为Ordered[T]上界
* Ordered继承： extends Any with java.lang.Comparable[A]
*/
class PairBetter[T <% Ordered[T]](val first: T, val second: T) {
def bigger = if (first.compareTo(second) > 0) first else second
}
object ViewVariablesBounds {
def main(args: Array[String]): Unit = {
// 函数调用
var pair = new PairNotPerfect("Spark", "Hadoop");
// 执行结果：Spark
println(pair.bigger)
// 函数调用,Int类型进行隐式转换，将Int -> RichInt,RichInt实现了Comparable接口
var pairInt = new PairNotPerfect(3,5)
// 执行结果：5
println(pairInt.bigger);
// 函数调用,Int类型进行隐式转换，将String -> RichString,RichString实现了Comparable接口
var pairBetterStr = new PairBetter("Java","Scala");
println(pairBetterStr.bigger);
// 函数调用
var pairBetterInt = new PairBetter(20, 12);
// 执行结果：Spark
println(pairBetterInt.bigger)
}
}
1.4 上下文界定
上下文界定：上下文界定是隐式参数的语法糖。如：Ordering：可以进行隐式转化的T类型。
class PairOrdering[T: Ordering](val first: T, val second: T) {
// compareTo方法进行比较，如果大于0返回first
def bigger(implicit ordered: Ordering[T]) = if (ordered.compare(first, second) > 0) first else second
}
object ContextBounds {
def main(args: Array[String]): Unit = {
// 函数调用
var pair = new PairOrdering("Spark", "Hadoop")
// 执行结果：Spark
println(pair.bigger)
}
}
1.5 Manifest关键字
Manifest关键字：数组在声明时必须要求指定具体的类型，在函数泛型是无法知道具体类型，通过Manifest关键字使得运行时可以根据这个Manifest参数做更多的事情。
def main(args: Array[String]): Unit = {
/*
* 定义方法array
* Manifest:需要运行时存储T的实际类型，运行时是做为参数运行在方法的上下文中。
* 数组在定义时必须知道具体的类型，所以在声明方法时，需要添加Manifest
*/
def arrayMake[T: Manifest](first: T, second: T) = {
val r = new Array[T](2);
r(0) = first;
r(1) = second;
// 返回r
r;
}
/*
* 执行结果：
* 1
* 2
*/
arrayMake(1,2).foreach(println)
}
1.6 ClassTag关键字
ClassTag[T]保存了泛型擦除后的原始类型T,提供给被运行时的。
def main(args: Array[String]): Unit = {
/*
* ClassTag:在运行时指定，在编译时无法确定的
*/
def mkArray[T:ClassTag](elems:T*) = Array[T](elems:_*)
/*
* 执行结果：
* 42
* 13
*/
mkArray(42,13).foreach(println)
/*
* 执行结果：
* Japan
* Brazil
* Germany
*/
mkArray("Japan","Brazil","Germany").foreach(println)
}
1.7 ClassManifest关键字
在引入Manifest的时候，还引入了一个更弱一点的ClassManifest，所谓的弱是指类型信息不如Manifest那么完整。用TypeTag替代了Manifest，用ClassTag替代了ClassManifest，原因是在路径依赖类型中，Manifest存在问题。
class A[T]
val m = manifest[A[String]]
// 执行结果：com.scala.type_param.Manifest_ClassTag$A$1[java.lang.String]
println(m);
val cm = classManifest[A[String]]
// 执行结果：com.scala.type_param.Manifest_ClassTag$A$1[java.lang.String]
println(cm);
1.8 多重界定符
/* // 表示：A和B为T上界 T <: A with B // 表示：A和B为T下界 T >: A with B // 表示：同时拥有上界和下界，并且A为下界，B为上界，A为B的子类，顺序不能颠倒。 T >: A <: B // 表示：类型变量界定，即同时满足AT这种隐式值和BT这种隐式值 T:A:B // 表示：视图界定，即同时能够满足隐式转换的A和隐式转换的B T <% A <% B */
1.9 Scala类型约束
def main(args: Array[String]): Unit = {
// A =:=B // 表示A类型等同于B类型
// A <:<B // 表示A类型是B类型的子类
def rocky[T](i: T)(implicit ev: T <:< java.io.Serializable) {
// 执行结果：Life is short ,you need spark!!!
println("Life is short ,you need spark!!!")
}
rocky("Spark")
}
——厚积薄发(yuanxw)