combineByKey、reduceByKey、groupByKey

combineByKey

• combineByKey實際上是將參數傳遞給了combineByKeyWithClassTag來完成工作的

• reduceByKey和groupByKey底層也都是調用了combineByKeyWithClassTag這個方法

• combineByKeyWithClassTag

  • 針對pari RDD(k,v)進行操作， 使用自定義的聚合函數對相同key的元素進行聚合
  • 將(k,v)類型的數據轉換成(k,c)類型的數據

  def combineByKeyWithClassTag[C](
      createCombiner: V => C,
      mergeValue: (C, V) => C,
      mergeCombiners: (C, C) => C,
      partitioner: Partitioner,
      mapSideCombine: Boolean = true,
      serializer: Serializer = null)(implicit ct: ClassTag[C]): RDD[(K, C)] = self.withScope {...}

• 必須要傳三個參數

  • createCombiner：當第一次遇到key時，調用這個函數，將key對應的V轉換成C（初始化操作）
  • mergeValue：不是第一次遇到key時，調用這個函數，將key對應的V累加到第一次的C中（對這個分區中相同的key的進一步操作）
  • mergeCombiners：針對不同分區的操作，將相同Key的C合併成一個C

• 默認參數

  • partitioner：分區函數,默認爲HashPartitioner
  • mapSideCombine：是否需要在Map端進行combine操作，類似於MapReduce中的combine，默認爲true
  • serializer：序列化，用於數據存儲和傳輸

• 返回值RDD[(K, C)]

  • 表示根據相同的k，將value值由原來的V類型最後轉換爲C類型

案例一：

val a = sc.parallelize(List("dog","cat","gnu","salmon","rabbit","turkey","wolf","bear","bee"), 3)
val b = sc.parallelize(List(1,1,2,2,2,1,2,2,2), 3)
val c = b.zip(a)        // 利用拉鍊操作將兩個rdd轉換爲pari rdd

val d = c.combineByKey(
    List(_),            // 取出第一次出現的key的val，加入到list中
    (x:List[String], y:String) => y :: x,       // 取出第二次出現的key的val，加入到第一次key對應的list中
    (x:List[String], y:List[String]) => x ::: y // 將不同分區，相同的key，對應的list連接到一起
)


d.collect
res: Array[(Int, List[String])] = Array((1,List(cat, dog, turkey)), (2,List(gnu, rabbit, salmon, bee, bear, wolf)))

案例二：

val initialScores = Array(("Fred", 88.0), ("Fred", 95.0), ("Fred", 91.0), ("Wilma", 93.0), ("Wilma", 95.0), ("Wilma", 98.0))  
val d1 = sc.parallelize(initialScores)

// 定義一個元組類型(科目計數器,分數)
// type的意思是以後再這個代碼中所有的類型爲(Int, Double)都可以被記爲MVType
type MVType = (Int, Double) 
d1.combineByKey(  
  score => (1, score),  // 以分數作爲參數,對分數進行標記
  // 注意這裏的c1就是createCombiner初始化得到的結果(1, score)，對相同的key進行標記+1，分數累加
  (c1: MVType, newScore) => (c1._1 + 1, c1._2 + newScore),  
  // 對不同分區，相同key的(n, score)進行累加
  (c1: MVType, c2: MVType) => (c1._1 + c2._1, c1._2 + c2._2)  
).map 
{ 
case (name, (num, socre)) 
=> (name, socre / num)
 }.collect 

reduceByKey

• reduceByKey底層也是通過combineByKeyWithClassTag來實現的

reduceByKey的源碼

• combineByKeyWithClassTag的第一個參數默認爲(v: V) => v，所以對元素不會產生任何影響
• 第二、三兩個參數都一樣，是reduceByKey傳遞過來的，將兩個值變成一個值(V, V) => V

def reduceByKey(partitioner: Partitioner, func: (V, V) => V): RDD[(K, V)] = self.withScope {
combineByKeyWithClassTag[V]((v: V) => v, func, func, partitioner)
}

案例:

val a = sc.parallelize(List("dog", "tiger", "lion", "cat", "panther", "eagle"), 2)
val b = a.map(x => (x.length, x))    // 生成一個鍵值對類型的數據(字符串長度，字符串)
b.reduceByKey(_ + _).collect         // 將字符串長度相同的key，所對應的val累加
res: Array[(Int, String)] = Array((4,lion), (3,dogcat), (7,panther), (5,tigereagle))

groupByKey

• groupByKey底層也是通過combineByKeyWithClassTag來實現的

groupByKey 源碼

• groupByKey的返回值爲RDD[(K, Iterable[V])]，val值是一個迭代器，其內容包含所有key值爲K的元祖的value值
• 執行過程類似reduceByKey，只是已經幫你寫好了每個函數，但是參數mapSideCombine = false，也就意味着，不在map端執行，在reduce端執行
• 所以在大量數據處理的情況下：groupByKey不如reduceByKey

def groupByKey(partitioner: Partitioner): RDD[(K, Iterable[V])] = self.withScope {
val createCombiner = (v: V) => CompactBuffer(v)
val mergeValue = (buf: CompactBuffer[V], v: V) => buf += v
val mergeCombiners = (c1: CompactBuffer[V], c2: CompactBuffer[V]) => c1 ++= c2
val bufs = combineByKeyWithClassTag[CompactBuffer[V]](
  createCombiner, mergeValue, mergeCombiners, partitioner, mapSideCombine = false)
bufs.asInstanceOf[RDD[(K, Iterable[V])]]
}

案例：

val a = sc.parallelize(List("dog", "tiger", "lion", "cat", "spider", "eagle"), 2)
//keyBy算子的意思是以_.length這個值作爲key，其中value的返回值爲ArrayBuffer。
val b = a.keyBy(_.length) 
b.groupByKey.collect

res: Array[(Int, Seq[String])] = Array((4,ArrayBuffer(lion)), (6,ArrayBuffer(spider)), (3,ArrayBuffer(dog, cat)), (5,ArrayBuffer(tiger, eagle)))