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