scala知识点

1. val 和 var 区别

val a = 1 不可变
var b = 1 b =2 可变

---

2. 基础数值类型的顶层接口Any

Any：(AnyVal：( Int、Double、Float、 Lon、…））

---

3. 函数可变长度参数 *

  def main(args: Array[String]): Unit = {
    mut("a")
    mut("a", "b")
    mut("a", "b","c")
  }

  def mut(params: String*) = {
    params.foreach(println)
  }

---

4. 占位符 _

---

4.2 _*

_* 将 nums.tail 转化为参数序列
tail : Selects all elements except the first

    def sum(nums:Int*):Int = {
      if (nums.length == 0) 0
      else nums.head + sum(nums.tail:_*)
    }
    println(sum(1,2,3,4,5))

---

5. apply 伴生对象中apply的作用就是new伴生类，所以在调用时不用new class

---

6. Nil 创建一个空的List,

    println(Nil)  // List()
    println(1 :: Nil)  //List(1)

:: 该方法被称为cons，意为构造，向队列的头部追加数据，创造新的列表。用法为 x::list,其中x为加入到头部的元素，无论x是列表与否，它都只将成为新生成列表的第一个元素，x::list等价于list.::(x))

---

7.可变集合 VS 不可变集合（scala.collection.mutable VS scala.collection.immutable）

    import scala.collection.mutable.ArrayBuffer
    val c = ArrayBuffer[Int]()
    println(c.length)
    c += 1
    c += 2
    c += (3, 4, 5)
    c ++= Array(6, 7, 8)
    c.foreach(x => {
      println(s"e : ${x}")
    })
0
e : 1
e : 2
e : 3
e : 4
e : 5
e : 6
e : 7
e : 8

---

8. 隐式转换

8.1 隐式类型转换，将一个普通类增强为一个牛逼的类 [ 公式： implicit def x2y(普通的X)：牛逼的Y = new 牛逼的Y(…) ]

eg.

object T1 {
  def main(args:Array[String]):Unit = {
    val pig = new Man("猪")
    pig.fly() //猪 fly  tree >>>>
  }
  implicit def man2superman(man:Man):Superman = new Superman(man.name)
}
class Man(val name:String)
class Superman(val name:String){
  def fly():Unit = {
    println(s"${name} fly  tree >>>>")
  }
}

eg. 将隐式类型转换抽取到一个对象中,使用时导入

object ImplicitApp {
  implicit def man2superman(man:Man):Superman = new Superman(man.name)
}
---------------------------------------------------------------------------------------
import ImplicitApp.man2superman
object T1 {
  def main(args:Array[String]):Unit = {
    println(Nil)
    println(1 :: Nil)
    val pig = new Man("猪")
    pig.fly()
  }
}
class Man(val name:String)
class Superman(val name:String){
  def fly():Unit = {
    println(s"${name} fly  tree >>>>")
  }
}

spark源码中的隐式类型转换定义在伴生对象中

object RDD {

  implicit def rddToPairRDDFunctions[K, V](rdd: RDD[(K, V)])
    (implicit kt: ClassTag[K], vt: ClassTag[V], ord: Ordering[K] = null): PairRDDFunctions[K, V] = {
    new PairRDDFunctions(rdd)
  }

  implicit def rddToAsyncRDDActions[T: ClassTag](rdd: RDD[T]): AsyncRDDActions[T] = {
    new AsyncRDDActions(rdd)
  }

  implicit def rddToSequenceFileRDDFunctions[K, V](rdd: RDD[(K, V)])
      (implicit kt: ClassTag[K], vt: ClassTag[V],
                keyWritableFactory: WritableFactory[K],
                valueWritableFactory: WritableFactory[V])
    : SequenceFileRDDFunctions[K, V] = {
    implicit val keyConverter = keyWritableFactory.convert
    implicit val valueConverter = valueWritableFactory.convert
    new SequenceFileRDDFunctions(rdd,
      keyWritableFactory.writableClass(kt), valueWritableFactory.writableClass(vt))
  }

  implicit def rddToOrderedRDDFunctions[K : Ordering : ClassTag, V: ClassTag](rdd: RDD[(K, V)])
    : OrderedRDDFunctions[K, V, (K, V)] = {
    new OrderedRDDFunctions[K, V, (K, V)](rdd)
  }

  implicit def doubleRDDToDoubleRDDFunctions(rdd: RDD[Double]): DoubleRDDFunctions = {
    new DoubleRDDFunctions(rdd)
  }

  implicit def numericRDDToDoubleRDDFunctions[T](rdd: RDD[T])(implicit num: Numeric[T])
    : DoubleRDDFunctions = {
    new DoubleRDDFunctions(rdd.map(x => num.toDouble(x)))
  }
}

---

8.2 隐式类 为已存在的类增强新的方法和能力

object T1 {
  def main(args:Array[String]):Unit = {
    println(2.add(3))
  }
  implicit class AA(x:Int){
    def add(a:Int) = a +x
  }
}

---

8.3 隐式参数 上下文寻找隐式值（符合参数类型的隐式值）

object T1 {
  def main(args:Array[String]):Unit = {
    implicit val word = "world"
    sayHello
  }

  def sayHello(implicit msg:String):Unit = {
    println(s"Hello: ${msg}")
  }
}

eg. 当存在两个或者多个相同类型隐式值时，报错

object T1 {
  def main(args:Array[String]):Unit = {
    implicit val word = "world"
    implicit val word2 = "world2"
    sayHello
  }

  def sayHello(implicit msg:String):Unit = {
    println(s"Hello: ${msg}")
  }
}

---

9 scala 中 Class[T]

  /**
   * Retrieve the runtime representation of a class type. `classOf[T]` is equivalent to
   * the class literal `T.class` in Java.
   *
   * @example {{{
   * val listClass = classOf[List[_]]
   * // listClass is java.lang.Class[List[_]] = class scala.collection.immutable.List
   *
   * val mapIntString = classOf[Map[Int,String]]
   * // mapIntString is java.lang.Class[Map[Int,String]] = interface scala.collection.immutable.Map
   * }}}
   */
  def classOf[T]: Class[T] = null // This is a stub method. The actual implementation is filled in by the compiler.

  /** The `String` type in Scala has methods that come either from the underlying
   *  Java String (see the documentation corresponding to your Java version, for
   *  example [[http://docs.oracle.com/javase/8/docs/api/java/lang/String.html]]) or
   *  are added implicitly through [[scala.collection.immutable.StringOps]].
   */
  type String        = java.lang.String
  type Class[T]      = java.lang.Class[T]

10 scala与java集合互转

import collection.JavaConverters._


import collection.JavaConverters._
import collection.mutable._
val map = Map("k" -> "v")
//转换成java
val javaMap = map.asJava
//转换成 scala
javaMap.asScala

---