Spark的RDD操作之Join大全！

一、RDD的Join操作有哪些？

/**
* Return an RDD containing all pairs of elements with matching keys in `this` and `other`. Each
* pair of elements will be returned as a (k, (v1, v2)) tuple, where (k, v1) is in `this` and
* (k, v2) is in `other`. Uses the given Partitioner to partition the output RDD.
*/
def join[W](other: RDD[(K, W)], partitioner: Partitioner): RDD[(K, (V, W))] = self.withScope {
this.cogroup(other, partitioner).flatMapValues( pair =>
for (v <- pair._1.iterator; w <- pair._2.iterator) yield (v, w)
)
}

/**
* Perform a left outer join of `this` and `other`. For each element (k, v) in `this`, the
* resulting RDD will either contain all pairs (k, (v, Some(w))) for w in `other`, or the
* pair (k, (v, None)) if no elements in `other` have key k. Uses the given Partitioner to
* partition the output RDD.
*/
def leftOuterJoin[W](
other: RDD[(K, W)],
partitioner: Partitioner): RDD[(K, (V, Option[W]))] = self.withScope {
this.cogroup(other, partitioner).flatMapValues { pair =>
if (pair._2.isEmpty) {
pair._1.iterator.map(v => (v, None))
} else {
for (v <- pair._1.iterator; w <- pair._2.iterator) yield (v, Some(w))
}
}
}

/**
* Perform a right outer join of `this` and `other`. For each element (k, w) in `other`, the
* resulting RDD will either contain all pairs (k, (Some(v), w)) for v in `this`, or the
* pair (k, (None, w)) if no elements in `this` have key k. Uses the given Partitioner to
* partition the output RDD.
*/
def rightOuterJoin[W](other: RDD[(K, W)], partitioner: Partitioner)
: RDD[(K, (Option[V], W))] = self.withScope {
this.cogroup(other, partitioner).flatMapValues { pair =>
if (pair._1.isEmpty) {
pair._2.iterator.map(w => (None, w))
} else {
for (v <- pair._1.iterator; w <- pair._2.iterator) yield (Some(v), w)
}
}
}

下面我们用一个非常简单的栗子，来进行比较说明：

首先rdd1是一个行业基本RDD，包含ID和行业名称，rdd2是一个行业薪水RDD，包含ID和薪水。

[plain] view plain copy

<code class="language-plain">//设置运行环境
val conf = new SparkConf().setAppName("SparkRDDJoinOps").setMaster("local[4]")
val sc = new SparkContext(conf)
//建立一个基本的键值对RDD，包含ID和名称，其中ID为1、2、3、4
val rdd1 = sc.makeRDD(Array(("1","Spark"),("2","Hadoop"),("3","Scala"),("4","Java")),2)
//建立一个行业薪水的键值对RDD，包含ID和薪水，其中ID为1、2、3、5
val rdd2 = sc.makeRDD(Array(("1","30K"),("2","15K"),("3","25K"),("5","10K")),2)
println("//下面做Join操作，预期要得到（1,×）、（2,×）、（3,×）")
val joinRDD=rdd1.join(rdd2).collect.foreach(println)
println("//下面做leftOutJoin操作，预期要得到（1,×）、（2,×）、（3,×）、(4,×）")
val leftJoinRDD=rdd1.leftOuterJoin(rdd2).collect.foreach(println)
println("//下面做rightOutJoin操作，预期要得到（1,×）、（2,×）、（3,×）、(5,×）")
val rightJoinRDD=rdd1.rightOuterJoin(rdd2).collect.foreach(println)
sc.stop()</code>

//设置运行环境
val conf = new SparkConf().setAppName("SparkRDDJoinOps").setMaster("local[4]")
val sc = new SparkContext(conf)
//建立一个基本的键值对RDD，包含ID和名称，其中ID为1、2、3、4
val rdd1 = sc.makeRDD(Array(("1","Spark"),("2","Hadoop"),("3","Scala"),("4","Java")),2)
//建立一个行业薪水的键值对RDD，包含ID和薪水，其中ID为1、2、3、5
val rdd2 = sc.makeRDD(Array(("1","30K"),("2","15K"),("3","25K"),("5","10K")),2)
println("//下面做Join操作，预期要得到（1,×）、（2,×）、（3,×）")
val joinRDD=rdd1.join(rdd2).collect.foreach(println)
println("//下面做leftOutJoin操作，预期要得到（1,×）、（2,×）、（3,×）、(4,×）")
val leftJoinRDD=rdd1.leftOuterJoin(rdd2).collect.foreach(println)
println("//下面做rightOutJoin操作，预期要得到（1,×）、（2,×）、（3,×）、(5,×）")
val rightJoinRDD=rdd1.rightOuterJoin(rdd2).collect.foreach(println)
sc.stop()

结果就证明了我们的预期。 --------------------- 本文来自 PMP4561705 的CSDN 博客，全文地址请点击：https://blog.csdn.net/PMP4561705/article/details/53212196?utm_source=copy