大数据系列修炼-Scala课程45

大数据系列修炼-Scala课程45

核心内容:

1、Scala中Context界定代码实战及其在Spark中的应用源码解析

1、Scala中Context界定操作代码实战

在视图界定中(T<%V)，T到V实际上存在着一个隐式的转换，但是这个用法看起来有点麻烦，所以我们引出上下文界定

1>[T:Ordering]的含义：正如视图界定中那样，T本身是一个泛型，此时存在一个隐式的转换，这个值就是Ordering[T]

2>def bigger(implicit ordered:Ordering[T])：在bigger中有一个隐式的值，这个值就是ordered，为Ordering[T]类型，

效果bigger这个函数会隐式的传进来一个参数。

3>本节知识真正掌握还要看隐式转换。

实例程序:

//本程序的目的是掌握Scala中上下文界定实战及其在Spark中的应用源码解析
object App
{
def main(args:Array[String]):Unit=
{
//先复习视图界定
val aa = new A("Spark","Hadoop")
println(aa.bigger())
//问题1
val bb = new A(10,20)
println(bb.bigger)
//问题2:想用数学逻辑符号 > <
//凡是Java中自带的数据类型，其比较的标准已经定义好了
//在上下文界定中可以做出相同的效果
val cc = new Pair("Spark","Hadoop")
println(cc.bigger)
val dd = new Pair(100,20)
println(dd.bigger)
}
}
//尽管视图界定有优点，但是看上去优点复杂。
class A[T<%Ordered[T]](val first:T,val second:T)
{
def bigger() = if(first.>(second)) first else second
}
//上下文界定的修改：具体还要学习隐士转换
class Pair[T:Ordering](val first:T,val second:T)
{
def bigger(implicit ordered:Ordering[T]) = if(ordered.compare(first, second)>0) first else second
}

实例程序：深度思考1：结合文本中的例子联想到了一个隐式转化的具体用法，通过在类中的定义甚至在函数中的定义可以提供一个隐式的值，从而为下文服务。

object App2
{
def main(args: Array[String]): Unit =
{
var aa: Bigger[Int] = new Bigger[Int](10,20)
println(aa.fun())
}
}
class Bigger[T](var first:T,var second:T)(implicit m:Ordering[T])
{
def fun() = if(m.compare(first,second) >0 ) first else second
}

上文程序的运行结果是20。

在上面的程序中，实际上需要一个第三方的对象，所以我在类的定义中提供一个隐式的第三方对象，进而为下文服务。

实例程序:深度思考2：在视图界定A:B中，难道A必须是B的子类吗？答案：不是,只要A类型可以隐式的转化为B类型即可。

我在《深入理解Scala》这本书中的第155页的最下角：A<:B 的含义就是A必须是B的子类。所以一定要注意类型约束和上下文边界的区别。

object App2
{
def main(args: Array[String]): Unit =
{
var aa: Bigger[String] = new Bigger[String]("Spark","Hadoop")
println(aa.fun)
}
}
class Bigger[T:Comparator](var first:T,var second:T)
{
def fun(implicit m:Comparator[T]) = if(m.compare(first,second) >0 ) first else second
}

在上面的程序中，因为String不是Comparator[String]的子类，所以程序是错误的。但是String却是Ordering[String]的子类。说明String在scala中应该已经实现了Ordering.

实例程序：深度思考3：上下文界定是不是就是介绍ordering的具体用法呢？？？

答案：看起来应该是，所以本讲也许不用太多的灵活运用，当然这是我的推断！