Scala进阶实战

泛型

class Triple[T, P, S](val a : T, val b : P, val c :S)
    val triple = new Triple("Spark", 3, 3.141592654)
    val bigData =  new Triple[String, String, Char]("Spark","scala",'c')

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

    def biuldArray[T : ClassTag](len : Int) = new Array[T](len)
    println(biuldArray[Int](5).toList)

类型变量bounds

//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的父类
class Pair_Lower_Bound[T](val first : T, val second : T){
  def replaceFirst[R >: T](newFirst : R) = new Pair_Lower_Bound[R](newFirst, second)
}
val pair =new Pair("Spark","Hadoop")
println(pair.bigger)

View Bound

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
}

    //隐式转换Int => richInt
    val pairInt =new Pair_NotPerfect(3, 5)
    println(pairInt.bigger)

    //隐式转换String => richString
    val pairString =new Pair_NotPerfect("Spark", "Hadoop")
    println(pairInt.bigger)

    val pairInt_Pair_Better =new Pair_Better(20, 50)
    println(pair_Pair_Better.bigger)

    val pair_Pair_Better =new Pair_Better("Spark", "Hadoop")
    println(pair_Pair_Better.bigger)

Context Bounds

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
  }
}

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

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

Manifest/ ClassTag

    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)

    def manif[T](x : List[T])(implicit m : Manifest[T]) ={
      if (m <:< manifest[String])
        println("List strings")
      else {
        println("Some other type")
      }
    }

    manif(List("Spark", "Hadoop"))
    manif(List(1, 2))
    manif(List("Scala", 3))

    class A[T]

    val m = manifest[A[String]]
    println(m)
    val cm = classManifest[A[String]]
    println(cm)

    def mkArray[T : ClassTag](elems : T*) = Array[T](elems : _*)
    mkArray(42,13).foreach(println)
    mkArray("Japan","Brazil","Germany").foreach(println)

多重界定

    //T是A和B的子类
    def fun[T <: A with B]
    //下界是A上界是B
    def fun[T >: A <: B]
    //T : A &&T :B
    def fun[T : A : B]
    //T通过隐式转换可以转AB
    def fun[T <% A <% B]

类型约束

    // A =:= B   //表示A类型同等于B
    // A <:< B   //表示A类型是B类型的子类型
    def fun[T](i : T)(implicit x : T <:< java.io.Serializable){
      println("Great")
      fun("Scala")
      //fun(1)    X

协变/ 逆变

//A>:B  List[A]>:List[B]是协变
//A>:B  List[A]<:List[B]是逆变
//协变+逆变-
class P[+T](val first : T, val second : T){
    def replaceFirst[R >: T](newFirst : R) = new P[R] (newFirst, second)
}