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