/*** Scala中上下文界定内幕中的隐式参数与隐式参数的实战详解及其在Spark中的应用源码解析*/
//[T: Ordering] 这种写法 说明存在一个隐式类型Ordering[T]
class Pair_Implicits[T: Ordering](val first: T, val second: T){//声明一个隐式类型对象传入函数def bigger(implicit ordered: Ordering[T]) = {if (ordered.compare(first, second) > 0) first else second}
}class Pair_Implicitly[T: Ordering](val first: T, val second: T){def bigger =/***   在Predef中定义了implicitly一个方法 可以简化上面的写法*   @inline def implicitly[T](implicit e: T) = e*   不使用implicit的隐形类型转换*/if (implicitly[Ordering[T]].compare(first, second) > 0) first else second
}class Pair_Implicitly_Ordereded[T: Ordering](val first: T, val second: T) {def bigger = {import Ordered._if (first > second) first else second}
}object Context_Bounds_Internals {def main(args: Array[String]): Unit = {println(new Pair_Implicits(7, 9).bigger)println(new Pair_Implicitly(7, 9).bigger)println(new Pair_Implicitly_Ordereded(7, 9).bigger)}
}

import java.io.Fileimport scala.io.Sourceobject Context_Helper{  implicit class FileEnhancer(file : File){    def read = Source.fromFile(file.getPath).mkString  }implicit class Op(x:Int){def addSAP(second: Int) = x + second}
}
object Implicits_Class {def main(args: Array[String]){import Context_Helper._println(1.addSAP(2))println(new File("F:\\1.txt").read)}}

abstract class Template[T] {def add(x: T, y: T): T}
abstract class SubTemplate[T] extends Template[T] {def unit: T}
//执行过程检查当前作用是否有 implicit object 限定的 类型为 SubTemplate 的对象，
// 如有，则选取此对象。
object Implicits_Object {def main(args: Array[String]) {implicit object StringAdd extends SubTemplate[String] {override def add(x: String, y: String) = x concat yoverride def unit: String = ""}implicit object IntAdd extends SubTemplate[Int] {override def add(x: Int, y: Int) = x + yoverride def unit: Int = 0}//含有隐式参数，m是隐式对象部分def sum[T](xs: List[T])(implicit m: SubTemplate[T]): T ={println(xs,m)if (xs.isEmpty) m.unitelse m.add(xs.head, sum(xs.tail))}println(sum(List(1, 2, 3, 4, 5)))println(sum(List("Scala", "Spark", "Kafka")))}}

import scala.io.Source
import java.io.Fileclass RicherFile(val file:File){def read = Source.fromFile(file.getPath()).mkString
}class File_Implicits( path: String) extends File(path)
object File_Implicits{implicit def file2RicherFile(file:File)= new RicherFile(file) //File -> RicherFile
}object Implicits_Internals {def main(args: Array[String]) {/*** 这里没有导入隐式对象** 通过给File_Impkicits类 构建一个伴生对象 在伴生对象内部顶一个隐式转换的方法** 执行顺序:* 1.搜索File_Impkicits有无read方法* 2.在上下文上搜索(有无导入的隐式对象)* 3.搜索File_Impkicits的伴生对象内有无隐式转换  发现implicit关键 尝试匹配类型* 4.例如这里匹配file2RichFile(file: File) 返回类型为RichFile 在RichFile中发现read方法** 规则：* 1.编译器标记为implicit* 2.作用域规则：单一标识符，关联类或者对象* 3.隐式转换没有歧义* 4.单一调用规则*/println(new File_Implicits("F:\\1.txt").read)}
}

object First_Actor extends Actor {def act() {println(Thread.currentThread().getName())for (i <- 1 to 10) {println("Step : " + i)Thread.sleep(2000)}}
}
object Second_Actor extends Actor {def act() {println(Thread.currentThread().getName())for (i <- 1 to 10) {println("Step Further : " + i)Thread.sleep(2000)}}
}object Hello_Actor {def main(args: Array[String]) {First_Actor.startSecond_Actor.start}}

import scala.actors.Actor._
import scala.actors.Actorobject Actor_Message01 extends Actor {def act() {while(true){receive {case msg => println("Message content Actor from inbox: " + msg)}}}
}
object Actor_Messages {def main(args: Array[String]) {//匿名Actorval actor_Message = actor{//Actor伴生对象带有一个actor方法，来创建和启动actorwhile(true){receive {//偏函数，其中两个方法：apply()和isDefinedAt()。//其中apply()负责在匹配时解析数据。//isDefinedAt() 判断消息是否已经被定义成要处理的消息，如果是，返回true，交给apply()解析；否的话，返回false，不作处理。//Actor只是处理receive中可以匹配上的情况，不匹配的话，则会静悄悄的忽略掉。//Actor的邮箱里如果没有消息，或者没有匹配的消息，receive方案则会阻塞。case msg => println("Message content from inbox: " + msg)}}}val double_Message = actor{while(true){/*创建匿名actor,此处actor的a是小写，一定要注意*/receive {case msg : Double => println("Double Number from inbox: " + msg)case _ => println("Something Unkown" )}}}/*receive是偏函数，使用case匹配，如果没有匹配时会报错。偏函数，有apply isDefinedAt方法（判断消息是否已被定义为要处理的消息）receive中如果没有case，不会报错，只会忽略。偏函数只会对收到的消息中第一个定义为isDefinedAt为true的消息传递给偏函数的apply方法，apply方法再通过case匹配如果邮箱中没有isDefinedAt为true的消息，receive所在的actor处于阻塞状态。一直等待消息到来。*/Actor_Message01.start//!函数定义send(msg, Actor.rawSelf(scheduler))//向actor发送msgActor_Message01 ! "Hadoop"actor_Message.startactor_Message ! "Spark"double_Message ! Math.PIdouble_Message ! "Hadoop"}}

//定义一个case class作为消息体
case class Person(name: String, age: Int)class HelloActor extends Actor{def act(){while(true){receive {//用case class进行模式匹配消息case Person(name, age) => {println("Name: " + name + " : " + "Age: " + age)//向主线程发消息sender ! "Echo!!!"}case  _ => println("Something else...")}}}
}
object Actor_With_CaseClass {def main(args: Array[String]) {val hiActor = new HelloActorhiActor.starthiActor ! Person("Spark", 6)//让主线程接受消息(把主线程作为Actor使用) 默认是阻塞的self.receive{case msg => println("receive new msg:"+msg)}//receiveWithin偏函数 参数设置是超时时间self.receiveWithin(1000){case msg => println(msg)}}}

object NameResolver extends Actor{def act(){//用react方法来替代receive方法进行消息的处理，// react允许共享线程资料,react方法匹配一次并执行完成，然后会退出，// 通过再次调用act()方法来重新关联Actor的邮箱。
//    react {
//      case Net (name, actor) =>
//        actor ! getIp(name)
//        act  //通过调用继续处理邮箱信息
//      case "EXIT" => println("Name resolver exiting.")
//      case msg =>
//        println("Unhandled message : " + msg)
//          act
//    }//loop可以循环调用react来处理邮箱的信息loop {react {case Net (name, actor) =>actor ! getIp(name)case msg =>println("Unhandled message : " + msg)}}}def getIp(name : String) : Option[InetAddress] = {try{println(InetAddress.getByName(name))Some(InetAddress.getByName(name))} catch {case _ : UnknownHostException => None}}
}case class Net(name : String, actor: Actor)object Actor_More_Effective {def main(args: Array[String]) {NameResolver.startNameResolver ! Net("www.baidu.com", self)println(self.receiveWithin(1000){case x => x})}}

import scala.swing._object Hello_GUI extends SimpleSwingApplication{def top = new MainFrame {title = "Hello GUI"contents = new Button {text = "Scala and Spark!!!"}}
}

object For_Advanced {def main(args: Array[String]): Unit = {for(i <- List(1,2,3,4,5) ) {println(i)}//配数据中含有 Flink 的数据，并将打印出来for(index@"Flink" <- List("Hadoop","Spark","Flink") ) {println(index)}//匹配第2个元素为 hadoop的的key值for ((language,"Hadoop") <- Set("Scala"->"Spark","Java"->"Hadoop") ) println(language)//匹配第二个元素的数据类型为 Int的tuple，并将该tutple 的第一个元素打印出来for((k,v:Int) <- List(("Spark"->5),("Hadoop"->"Big Data"))) {println(k)}}}

  def main(args: Array[String]) {val a@b = 1000//@是别名的意思，a@b形成了tuple2二元元组//把1000赋值给a和b,并返回二元组的内容给val a@bprintln("a = " + a + ", b = " + b)val (c,d) = (1000,2000)
//    val (e,F) = (1000,2000)val Array(g,h) = Array(1000,2000)
//    val Array(i,J) = Array(1000,2000)
//    object Test { val 1 = 1 } object Test { val 1 = 2 }

object :>{  //定义提取器 :>def unapply[A](list:List[A]) = {Some(list.init,list.last)}
}object Extractor_Pattern_Match {def main(args: Array[String]) {(1 to 9).toList match { case :>(_,9) => println("aa")}(1 to 9).toList match { case _ :> 9 => println("spark")}(1 to 9).toList match { case x :> 8 :>9 => println("hadoop") }(1 to 9).toList match { case :>(:>(_,8),9)=>println("flink")}}
}

import scala.reflect.runtime.universe._class Spark
trait Hadoop
object Flink
class Java{class Scala
}
object Type_Advanced {def main(args: Array[String]) {println(typeOf[Spark])println(classOf[Spark]) //Class[_ <: Spark]表明子类val spark = new Sparkprintln(spark.getClass==classOf[Spark])//trueprintln(typeOf[Hadoop])println(classOf[Hadoop])println(Flink.getClass)//运行结果打印class com.dt.scala.bestpractice.Flink$//生动地告诉我们object背后是有具体的class的//println(classOf[Flink])  报没有找到Flink类错误//classOf与getClass基本是没有区别的，//但getClass是获得具体的类的子类，//classOf是类本身，println("********************************")val java1 = new Javaval java2 = new Javaval scala1 = new java1.Scalaval scala2 = new java2.Scalaprintln(scala1.getClass==scala2.getClass)//上面两例打印结果都是：Java$Scalaprintln(scala1.getClass)println(scala2.getClass)println(typeOf[java1.Scala] == typeOf[java2.Scala])println(typeOf[java1.Scala]) //打印结果：java1.Scalaprintln(typeOf[java2.Scala])//打印结果：java2.Scala//从打印结果可以看出typeOf返回具体信息，而getClass返回更高层的信息println("=========================================")println(classOf[List[Int]] == classOf[List[String]])//trueprintln(typeOf[List[Int]] == typeOf[List[String]])//false}}

import scala.reflect.runtime.universe._class Animal {def breathe : this.type = this
}
class Cat extends Animal {def eat : this.type = this
}object Scala
class Java1
class JVM { def method1: this.type = this }
class JVM_Language extends JVM { def method2 : this.type = this }
object Singleton_Type {def main(args: Array[String]){val cat=new Cat/*** 代码2 报错* cat.breathe 返回的是Animal的this* Animal实例没有eat方法，所以报错*//***为了到达链式调用，采用代码1* 注意:this.type=this** Q:type是指什么？* A:在Scala中任何类对象都有一个type属性** 当执行cat.breathe其实返回cat类实例的type* 而这个type有eat方法*/println("Test:"+cat.breathe)println(Scala.getClass)println(typeOf[Scala.type])val java = new Java1val java2 = new Java1println(typeOf[java.type])println(typeOf[java2.type])val content:java.type = java
//    val content:java.type = java2//说明任何一个实例对象都有唯一的单例//虽然背后的class是一样的,但typeOf是不一样的。//意义非常大，val jvm = new JVM_Languageprintln(jvm.method1)println(jvm.method1.method2)/*这是一个链式表达式，由于任何一个实例对象都有唯一的单例所以可以采用实例的type的方式，this就是jvm实例。所以jvm.method1返回的是jvm本身。这样就可以再返回.method2this.type是依附于具体实例的，所以是动态的。this.type就是利用this的动态特性完成了执行method1时返回的内容。这样可很好地做链式表达式。返回的是动态对象的单例本身。链式方式在spark的RDD中非常常见。*/}}