Scala零基础教学【41-60】

第41讲：List继承体系实现内幕和方法操作源码揭秘

  def main(args: Array[String]) {
    /**
      * List继承体系实现内幕和方法操作源码揭秘
      *
      * List本身是一个抽象类 定义如下：
      * abstract sealed class List[+A] extends AbstractSeq[A]
      * with LinearSeq[A]
      * with Product
      * with GenericTraversableTemplate[A, List]
      * with LinearSeqOptimized[A, List[A]]
      *
      * List下的两个重要的子类Nil和：：
      * Nil 表示一个空值  定义为一个Cass Object:  case object Nil extends List[Nothing]
      * :: 定义 final case class ::[B](private var hd: B, private[scala] var tl: List[B]) extends List[B]
      *
      */
    //这种方式其实是 调用List的伴生对象的apply方法  val list: List[Int]
    val list: List[Int] = List(1, 2, 3, 4, 5)
    //这是一种"协变"的概念  Int为Any的子类  所以认为List[Int]的具体父类型可以是List[Any]
    val listAny: List[Any] = list
    println(list.isEmpty)
    println(list.head)
    println(list.tail)
    println(list.length)
    println(list.drop(2))
    list.map(_ * 2)

  }

　　

第42讲：Scala中泛型类、泛型函数、泛型在Spark中的广泛应用

/**
  * 定义一个泛型类[]中定义的就是未知的类型 只有赋值使用才能确定具体的类型
  */
class Triple[F, S, T](val first: F, val second: S, val third: T)

/**
  * Scala中泛型类、泛型函数、泛型在Spark中的广泛应用
  */
object Hello_Type_Parameterization {

  def main(args: Array[String]) {
    //在定义后scala的类型推断会得出triple类型为 Triple[String, Int, Double]
    val triple = new Triple("Spark", 3, 3.1415)
    //显示声明类型
    val bigData = new Triple[String, String, Char]("Spark", "Hadoop", 'R')

    //定义泛型类型
    def getData[T](list : List[T]) = list(list.length / 2)
    //List(1)=>"Hadoop"
    println(getData(List("Spark", "Hadoop", 'R')))
    val f = getData[Int] _
    println(f(List(1,2,3,4,5,6)))//5

    val queue = Queue(1,2,3,4,5)
    val queue_appended = queue enqueue 6
    println("queue : " + queue + "   " + "queue_appended : " + queue_appended)

  }

}

　

第43讲：Scala中类型变量Bounds代码实战及其在Spark中的应用源码解析

/**
  * 类型的界定
  * 这里的[T <: Comparable[T]] 表示类型T必须是Comparable[T]的子类
  */
class Pair[T <: Comparable[T]](val first : T,val second : T){
  def bigger = if(first.compareTo(second) > 0)first else second
}
/**
  * [R >: T]表示 R类型是T类型的父类
  * 类型变量的界定 就R而言 T为R的下界   就T而言 R为T的上界
  *
  */
class Pair_Lower_Bound[T](val first:T,val second:T){
  def replaceFirst[R >: T](newFirst:R)= new Pair_Lower_Bound[R](newFirst,second)
}

object Typy_Variables_Bounds {

  def main(args: Array[String]){
    /**
      * 49-57:0-9
      * A-Z:66-90
      * a-z:97-122
      */
    val schar='S'
    println(schar.toInt)
    println('H'.toInt)
    println("Spark".compareTo("Hadoop"))//11
    val pair = new Pair("Spark", "Hadoop")
    println(pair.bigger)//Spark
  }
}

　　

第44讲：Scala中View Bounds代码实战及其在Spark中的应用源码解析

class Pair_NotPerfect2[T <: Comparable[T]](val first : T,val second : T){
  def bigger = if(first.compareTo(second) > 0)first else second
}

/**
  * 视图界定   <%
  */
/**
  * Ordered视图界定
  * 上面这种方式的12行first.compareTo(second) > 0 通过compareTo来比较 但是不能直观的像数学比较那样清晰
  * Scala提供了Ordered视图界定
  * Ordered在Comparable上提供一些关系型的操作符 < > <= >=等
  */
class Pair_NotPerfect[T <% Comparable[T]](val first : T,val second : T){
	def bigger = if(first.compareTo(second) > 0)first else second
}

class Pair_Better[T <% Ordered[T]](val first : T,val second : T){
	def bigger = if(first > second)first else second
}

object View_Bounds {

  def main(args: Array[String]) {

//    val pair2 = new Pair_NotPerfect2(1, 3)
//    println(pair2.bigger)

    val pair = new Pair_NotPerfect("Spark", "Hadoop")
    println(pair.bigger)
    /*
       * 当类型界定为Pair_NotPerfect[T <: Comparable[T]]报错 因为Int本身不是Comparable的子类
       *
       * 当类型界定为视图界定时 Pair_NotPerfect[T <% Comparable[T]] 就可以正常运行
       * 是因为Int本身不是Comparable的子类型 Scala通过"隐式转换"将Int转换成RichInt 而这个类型是Comparable的子类
       */
    val pairInt = new Pair_NotPerfect(3, 5) //Int -> RichInt
    println(pairInt.bigger)
    /**
      * 注意：这样定义不是因为String的上界是Ordered[String],String不是Ordered[String]的子类
      * 当使用视图界定时 会发生"隐式转换" 把String --> RichString
      * 而RichString是Ordered[RichString]的子类型  RichString中是实现了这样的 < > <= >=等方法
      * 从而真正是让String类型完成视图界定
      */
    val pair_Better_String = new Pair_Better("Java", "Scala") //String -> RichString
    println(pair_Better_String.bigger)

    val pair_Better_Int = new Pair_Better(20, 12)
    println(pair_Better_Int.bigger)

  }

}

　　

第45讲：Scala中Context Bounds代码实战及其在Spark中的应用源码解析

/**
  * 上下文界定  [T : Ordering]  说明存在一个隐式的值Ordering[T]    //implicit ordered: Ordering[T]
  *
  * Ordering源码声明:
  * trait Ordering[T] extends Comparator[T] with PartialOrdering[T] with Serializable
  */
class Pair_Ordering[T : Ordering] (val first : T, val second : T){

  //这是一个隐式转换的显式定义 这个函数没有参数 当时函数执行的时候 这个隐式值就会自动传进来
  def bigger(implicit ordered: Ordering[T]) = {
    if (ordered.compare(first, second) > 0) first else second
  }
}

object Context_Bounds {

  def main(args: Array[String]) {

    val pair = new Pair_Ordering("Spark", "Hadoop")
    println(pair.bigger)

    val pairInt = new Pair_Ordering(3, 5)
    println(pairInt.bigger)

  }

}

第46讲： ClassTag 、Manifest、ClassManifest、TypeTag代码实战及其在Spark中的应用源码解析

package com.wanji.scala.type_parameterization

import scala.reflect.ClassTag

class A[T]

/**
  * ClassTag 、Manifest、ClassManifest、TypeTag代码实战及其在Spark中的应用源码解析
  *
  * ClassTag ==> ClassManifest
  * TypeTag  ==> Manifest
  */

object Manifest_ClassTag {

  def main(args: Array[String]) {

    /**
      * Q: 可以创建泛型数组吗? 理论上是不可以的，因为没有指定具体的，在Scala程序运行中，数组必须有具体的类型，没有否无法创建的相应的数组
      *
      * 引出Manifest的概念可以创建泛型数组
      * [T : Manifest]这样的写法被称之为Manifest上下文界定  实质上这是需要一个Manifest[T]类型的隐式对象 这又是一个"隐式转换"的过程
      * 通过这个隐式的值来辅助构建泛型数组，来确定T的具体类型
      * 所以在创建泛型函数时 需要Manifest的类型来辅助构建泛型数组，借助Manifest类型对象来指定泛型数组具体的类型
      *
      * 通过Manifest[T]可以记录T的类型 在实际运行的时候我们获取T具体的类型
      **/

    def arrayMake[T: Manifest](first: T, second: T) = {
      val r = new Array[T](2)
      r(0) = first
      r(1) = second
      r
    }

    arrayMake(1, 2).foreach(println)

    /**
      * [T : ClassTag]这种写法说明 当这个函数在运行时 对存在一个ClassTag[T]一个隐式值 这种方式是最常用的
      */
    def mkArray[T: ClassTag](elems: T*) = Array[T](elems: _*)

    mkArray(42, 13).foreach(println)
    mkArray("Japan", "Brazil", "Germany").foreach(println)

    /**
      * Manifest的原生写法，不推荐
      */
    def manif[T](x: List[T])(implicit m: Manifest[T]) = {
      if (m <:< manifest[String]) //<:< 表示m是manifest[String]类型
        println("List strings")
      else
        println("Some other type")
    }

    manif(List("Spark", "Hadoop"))
    manif(List(1, 2))
    manif(List("Scala", 3))
    val m = manifest[A[String]]
    println(m)
    val cm = classManifest[A[String]]
    println(cm)
  }

}

　

第47讲：Scala多重界定代码实战及其在Spark中的应用源码解析

class M_A[T]
class M_B[T]

/**
  * scala多重界定代码实战及其在Spark中的应用源码解析
  *
  * T<：A with B
  * T是A或者B的子类
  *
  * T>：A with B
  * A或者B是T的子类
  *
  * T>:A <：B (写法上 下界必须在前边 上届必须在后面)
  * T同时拥有下界A和上界B(A必须为B的子类型) 但是T不能同时拥有多个上界或者多个下界
  *
  * T：A：B(上下文界定)
  *
  * T <% A <% B(视图界定)  T必须能够同时转化为A和B的要求
  * T可以< 同时>拥有多个视图界定
  * T可以通过"隐式转换"为A 也可以"隐式转换"为B
  *
  */

object Multiple_Bounds {

  def main(args: Array[String]) {
    implicit val a = new M_A[Int]
    implicit val b = new M_B[Int]
    def foo[ T : M_A : M_B ](i:T) = println("OK")
    foo(2)

  }

}

　　

第48讲：Scala类型约束代码实战及其在Spark中的应用源码解析

/**
  * Scala类型约束代码实战及其在Spark中的应用源码解析
  *
  * A =:= B 表示A类型等同于B类型
  * A <：< B 表示A类型是B类型的子类型
  */

object Type_Contraints {

  def main(args: Array[String]){

    def rocky[T](i:T)(implicit ev: T <:< java.io.Serializable) {
      print("Life is short,you need spark!") }
      rocky("Spark")
  }

}

　

第49讲：Scala中Variance代码实战及其在Spark中的应用源码解析

/**
  * Scala中Variance代码实战及其在Spark中的应用源码解析
  *
  * 通俗讲
  * B是A的子类 ==>List[B]是List[A]的子类(与具体元素的继承关系同向)  这样称之为"协变"
  * B是A的子类 ==>List[A]是List[B]的子类(与具体元素的继承关系反向)  这样称之为"逆变"
  * 如果支持上面的这种概念 就被称之为"Variance" 否则称之为"inVariance"
  *
  * 事实上Java不支持在定义一个类型时声明为这样的"Variance"
  * e.g. String是object的子类，List<String> 却不是 List<Object>的子类
  * 但是Java中是存在这样的痕迹的 比如:
  * List<? extends Object> list = new ArrayList<String>()
  * 在Scala中也是可以向上面这样写的:
  * val list: List[_ <: Any] = List[String]("Spark", "Hadoop")
  *
  * 事实上Java支持在使用的时候 可以这样去定义，在声明的时候不支持，但是Scala中的可以
  *
  * Scala中 在声明时留意表达这种Variance的关系
  * 形如class C[+T] “+”表示"协变" 也就是说若B为A的子类型 则C[B]是C[A]的子类型
  *    class C[-T] “-”表示"协变" 也就是说若B为A的子类型 则C[A]是C[B]的子类型
  *
  */

class Person
class Student extends Person
class C[+T](val args: T)
class S[+T](arg : T) extends C[T](arg)
trait Friend[-T]{
  def makeFriend(somebody: T)
}

object Variance {
  def makeFriendWithYou(s: Student, f: Friend[Student]){f.makeFriend(s)}
  def main(args: Array[String]) {
    val value : C[Person] = new C[Student](new Student)

//    List<? extends Oject> list = new ArrayList<String>()
    val list : List[_ <: Any] = List[String]("Spark")
  }

}

第50讲：Scala中Variance变化点及其在Spark中的应用源码解析

package com.wanji.scala.type_parameterization

//class P[+T](val first: T, val second: T)
class P[+T](val first: T, val second: T){
//  def replaceFirst(newFirst: T) = new P[T](newFirst, second)
  //方法是泛型的  方法的参数是逆变点 返回值是协变的协变点
  def replaceFirst[R >: T](newFirst: R) = new P[R](newFirst, second)
}

object Variant_Positions {

  def main(args: Array[String]) {

  }

}

　　

第51讲：Scala中链式调用风格的实现代码实战及其在Spark编程中的广泛运用

package com.wanji.scala.type_parameterization

class Animal { def breathe:this.type=this }
class Cat extends Animal { def eat :this.type= this }

object Singleton_Types {

  def main(args: Array[String]): Unit = {
    /* * 代码2 报错
    * * cat.breathe 返回的是Animal的this Animal实例没有eat方法 所以报错
    * */
    /*
    * * 为了到达链式调用 采用代码1
    * * 注意:this.type = this       *
    * * Q:type是指什么？
    * * A:在Scala中 任何类对象都有一个type属性
    * * 当执行cat.breathe其实返回的Cat类实例的type 而这个type有eat方法
    * */
    val cat = new Cat
    cat.breathe.eat
  }

}

　第52讲：Scala中路径依赖代码实战详解

   val outer = new Outer
    val inner =  new outer.Inner

    /**
      * Scala中的内部类 必须依赖于外部类的实例 而外部类的实例各不相同
      * 所以被之为这种对于外部类的依赖为"路径依赖"
      * 所以不同的路径代表不同的类型
      */
    val inner2: outer.Inner = new outer.Inner
    println(inner)
    println(inner2)

    val o1 = new Outer
    val o2 = new Outer
    //报错 o1与o2不是同样的实例
    //val i2: o2.Inner = new o1.Inner
    val i: Outer#Inner = new o1.Inner
    //o1.Inner是Outer#Inner的子类。外部类#内部类：类型投影（不同外部类实例，但内部类是同一类型）。
    //虽有路径依赖，但还想用Java风格就用这种表达方式。

　　

例如：
有2个社交网络，facebook和twitter，有很多会员，是依赖于各自网络的。
就算是同一个人在这两个不同的社交网络里，也是不同的实例。
spark编程中，数据是分布式的，会分成很多的片，不同分片的数据从理论上讲是一样的（当然数据内容不同），也就是说，属于同样类型的数据，但是我们写代码时，处理数据时，还是处理属于每一个blog或split分片的结果。从这个角度看，也可看作是路径依赖。

第53讲：Scala中结构类型实战详解

/**
  * Scala中结构类型实战详解
  * 结构类型不关心传入的类型 只关心传入的对象具有某种行为
  */
class Structural {
  def open()=print("A class instance Opened")
}

object Structural__Type {

  def main(args: Array[String]){
    init(new { def open()=println("Opened") })

    /**
      * type的作用是把“=”右边的内容起个别名
      */
    type X = { def open():Unit }

    def init(res:X) = res.open

    init(new { def open()=println("Opened again") })
    /**
      * 定义单例对象
      */
    object A {
      def open() {println("A single object Opened")}
    }
    init(A)

    val structural = new Structural
    init(structural)

  }

  /**
    * 从函数的定义来看，并不关心传入的对象为何，只关心传入的对象必须具有open方法
    *
    */
  def init( res: {def open():Unit} ) {
            res.open
        }
}

第54讲：Scala中复合类型实战详解

trait Compound_Type1;
trait Compound_Type2;
class Compound_Type extends Compound_Type1 with Compound_Type2

object Compound_Type {
  def compound_Type(x: Compound_Type1 with Compound_Type2) = {
    println("Compound Type in global method")
  }

  def main(args: Array[String]) {

    compound_Type(new Compound_Type1 with Compound_Type2)
    object compound_Type_oject extends Compound_Type1 with Compound_Type2
    compound_Type(compound_Type_oject)

    type compound_Type_Alias = Compound_Type1 with Compound_Type2
    def compound_Type_Local(x:compound_Type_Alias) = println("Compound Type in local method")
    val compound_Type_Class = new Compound_Type
    compound_Type_Local(compound_Type_Class)

    type Scala = Compound_Type1 with Compound_Type2 { def init():Unit }
  }

}

　　

第55讲：Scala中Infix Type实战详解

 def main(args: Array[String]) {

    object Log { def >>:(data:String):Log.type = { println(data); Log } }
    "Hadoop" >>: "Spark" >>: Log

     val list = List()
     val newList = "A" :: "B" :: list
     println(newList)

    class Infix_Type[A,B]
    val infix: Int Infix_Type String = null
    val infix1: Infix_Type[Int, String] = null

    case class Cons(first:String,second:String)
    val case_class = Cons("one", "two")
    case_class match { case "one" Cons "two" => println("Spark!!!") } //unapply

  }

　　第56讲：Scala中Self Types实战详解

/**
  * Scala中Self Types实战详解
  */
class Self {
    self =>  //用法一：self => 表示this的别名 这是self和this等价   注意不能使用this作为别名
    val tmp="Scala"
    def foo = self.tmp + this.tmp
}
trait S1
class S2 {
  /**
    * 用法二：
    * 这种方式和self =>并不一样  将S1比如为摸个trait是
    * 这种this:S1为this的别名时 有一个强制的要求
    * (1)在该类型实例化时 必须混入这个类型 即: val c = new S2 with S1 否则报错
    * (2)在继承该类的子类是 也必须混入 比如:class S3 extends S2 with S1 若不混入with S1则报错
    * */

  this:S1 =>
}
class S3 extends S2 with S1

trait T { this:S1 => }
object S4 extends T with S1
object Self_Types {

  def main(args: Array[String]) {
    class Outer { outer =>
	    val v1 = "Spark"
	    class Inner {
        /**
          *  用法三：
          *  这里内部类需要访问外部类成员和方法
          *  通过定义了outer =>代替了外部类Outer的this
          *  在内部类理由直接引用不需要考虑this是谁this
          *  这是使用这种方式声明的好处
          *  如果写成println(this.v1)则报错 因为这个this代表了Inner的this
          *  下面的三种写法都是正确的  */

        println(outer.v1)
        println(v1)
        println(Outer.this.v1)
	    }
    }
    val c = new S2 with S1
  }

}

　

第57讲：Scala中Dependency Injection实战详解

trait Logger {
  def log (msg : String) }
trait Auth {
    auth : Logger =>
    def act(msg : String) {
        log(msg)
    }
}
object DI extends Auth with Logger {
  override def log(msg : String) = println(msg); }
object Dependency_Injection {

  def main(args: Array[String]) {
    DI.act("I hope you'll like it")
  }

}

第58讲：Scala中Abstract Types实战详解

import scala.io.Source
import scala.io.BufferedSource

trait Reader{
  /**
    * 用type关键字 声明一个In类型（称为"抽象类型"）
    * 但是没有指明具体类型是什么类型 需要在它的实现类中指明具体的类型
    * 在声明抽象类型时 可以对类型进行限定
    */
  type In <: java.io.Serializable
  type Contents

  /**
    *在抽象对的可以使用抽象类型
    */
  def read(in: In): Contents
}
class FileReader extends Reader {
  type In = String   //实现中具体的类型
  type Contents = BufferedSource  //type Contents=Contents
  override def read(name: In)  = Source.fromFile(name)
}
object Abstract_Types {

  def main(args: Array[String]) {
    val fileReader = new FileReader
    val content = fileReader.read("F:\\1.txt")
    for (line <- content.getLines){
		  println(line)
		}
  }

}

　　

第59讲：Scala中隐式转换初体验实战详解以及隐式转换在Spark中的应用源码解析

import scala.io.Source
import java.io.File

/**
  * Scala中隐式转换初体验实战详解以及隐式转换在Spark中的应用源码解析
  */
//这里的RichFile相当于File的增强类 需要的将要增强的类作为参数传入构造器中
class RichFile(val file:File){
   def read = Source.fromFile(file.getPath()).mkString
}

object Context{
    //File --> RichFile
    //implicit是隐式转换的关键字 这里定义一个隐式转换函数把当前类型转换成增强的类型
    implicit def file2RichFile(file:File)= new RichFile(file) //File -> RichFile
}
object Hello_Implicit_Conversions {

  def main(args: Array[String]) {
   	  import Context.file2RichFile
    //File类本身没有read方法 通过隐式转换完成
    //这里的read方法是RichFile类中的方法  需要通过隐式转换File --> RichFile
	  println(new File("F:\\1.txt").read)
  }
}

　第60讲：Scala中隐式参数实战详解以及隐式参数在Spark中的应用源码解析

/**
  * Scala中隐式参数实战详解以及隐式参数在Spark中的应用源码解析
  */
object Context_Implicits{
    implicit val default:String = "Flink"
}

object Param{
   def print(content:String)(implicit language:String){
      println(language+":"+content)
   }
}
object Implicit_Parameters {

  def main(args: Array[String]) {
    Param.print("Spark")("Scala")

    import Context_Implicits._
    //隐式参数没有传值，编译器会在全局范围内搜索 有没有implicit String类型的隐式值 并传入
    Param.print("Hadoop")
  }
}