Spark一路火花带闪电——Pair RDD常用算子(参数及其返回值)探究

转化算子

以键值对集合{(1,2),(3,4),(3,6)}为例
RDD[U,T]注意下面的函数，对应U和T

---

• reduceByKey(f:(T,T) => T):RDD[U,T]

合并具有相同值的键
rdd.reduceByKey((x,y)=>x+y)
>>(1,2)(3,10)

---

• groupByKey():RDD[Tuple（T, Iterable [U]）]

对具有相同键的值进行分组
rdd.groupByKey()
>> {(1,[2]),(3,[4,6])}输出为元组

---

• combineByKey(createCombiner :T => C, mergeValue :(C,T)=>C, mergeCombiners :(C,C)=>C, numPartitions : Int):RDD[Tuple[K, C]]

和aggregate()函数相似：

1. zeroValue:C -------- createCombiner :T => C,
2. SepOp(C,T)=>C -------- mergeValue :(C,T)=>C,
3. comOp:(C,C)=>C -------- mergeCombiners :(C,C)=>C
   createCombiner: T => C ，这个函数把当前的值作为参数，此时我们可以对其做些附加操作(类型转换)并把它返回 (这一步类似于初始化操作)
   mergeValue: (C,T)=>C，该函数把元素T合并到之前的元素C(createCombiner)上 (这个操作在每个分区内进行)
   mergeCombiners: (C, C) => C，该函数把2个元素C合并 (这个操作在不同分区间进行)

	type Ctype=(Int,Int)
    val s=rdd.combineByKey(x=>(x,1),(c:Ctype, x)=>(c._1+x,c._2+1),
      (c:Ctype,d:Ctype)=>(c._1+d._1,c._2+d._2))
    s.foreach(println(_))

>>>
(1,(2,1))
(3,(10,2))

---

• mapValues(f:T => K):RDD[U,K]

对RDD的每个值T应用一个函数，不改变键。
rdd.mapValues(x => x+1)
>>{(1,3),(3,5),(3,7)}

---

• flatMapValues(f:T => K):RDD[U,K]

与mapValues不同的是，传入的函数返回的是迭代器。
rdd.flatMapValues(x=>(x to 5))
>>{(1,2),(3,4),(1,3),(3,5),(1,4),(1,5)}

以两个键值对集合{(1,2),(3,4),(3,6)}和{(3,9)}为例
以RDD[U,T]为初始RDD.

---

• subtractByKey(other:RDD[U,K]):RDD[U,T]

删掉两个rdd里键相同的元素（不管值是否相同，也不管值的类型是否相同）。
rdd.subtractByKey(rdd2)
>>{(1,2)}

---

• join(other:RDD[U,K]):RDD[U,Tuple(T,K)]

合并两个rdd里键相同的元素（不管值是否相同，也不管值的类型是否相同）。
rdd.join(rdd2)
>>{(3,(4,9)),(3,(6,9))}

---

• rightOuterJoin(other:RDD[U,K]):RDD[U,(option(T),K)]

右外连接操作（不管值是否相同，也不管值的类型是否相同）。
rdd.rightOuterJoin(rdd2)
>>{(3,(Some(4),9)),(3,(Some(6),9))}

---

• leftOuterJoin(other:RDD[U,K]):RDD[U,(T, option(K))]

左外连接操作（不管值是否相同，也不管值的类型是否相同）。
rdd. leftOuterJoin(rdd2)
>>{(1,(2,None)),(3,(4,Some(9))),(3,(6,Some(9)))}

---

• cogroup(other:RDD[U,K]):RDD[U,(Iterable(T),Iterable(K))]

按键数据分组。
rdd.cogroup(rdd2)
>>(1,(CompactBuffer(2),CompactBuffer()))(3,(CompactBuffer(4, 6),CompactBuffer(9)))

行动算子

以键值对集合{(1,2),(3,4),(3,6)}为例
RDD[U,T]注意下面的函数，对应U和T

---

• countByValue():Map[U,Long]

按键来计数。
rdd.countByKey()
>>(1,1),(3,2)

---

• collectAsMap():Map(U,T)

键结果以映射表的形式返回，以便查询。

---

• lookup(key:U):Seq[T]

返回给定的键所对应的所有值。
rdd.lookup(3)
>>4,6