Spark 键值对RDD操作

最新推荐文章于 2024-08-07 22:11:09 发布

hsg77

最新推荐文章于 2024-08-07 22:11:09 发布

阅读量1.3k

点赞数 1

分类专栏： spark

本文链接：https://blog.csdn.net/hsg77/article/details/87277040

版权

spark 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

Spark 键值对RDD操作
键值对的RDD操作与基本RDD操作一样，只是操作的元素由基本类型改为二元组。
概述
键值对RDD是Spark操作中最常用的RDD，它是很多程序的构成要素，因为他们提供了并行操作各个键或跨界点重新进行数据分组的操作接口。
创建
Spark中有许多中创建键值对RDD的方式，其中包括

1文件读取时直接返回键值对RDD
2通过List创建键值对RDD

在spark-shell 中，可通过Map函数生成二元组

scala> val listRDD=sc.parallelize(List(1,2,3,4,5))
listRDD: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[0] at parallelize at <console>:24

scala> val result=listRDD.map(x=>(x,1))
result: org.apache.spark.rdd.RDD[(Int, Int)] = MapPartitionsRDD[1] at map at <console>:25

scala> result.collect.foreach(println)
(1,1)
(2,1)
(3,1)
(4,1)
(5,1)

键值对RDD的转化操作

基本RDD转化操作在此同样适用。但因为键值对RDD中包含的是一个个二元组，所以需要传递的函数会由原来的操作单个元素改为操作二元组。

下表总结了针对单个键值对RDD的转化操作，
以 { (1,2) , (3,4) , (3,6) } 为例，f表示传入的函数
///
函数名目的示例结果
reduceByKey(f) 合并具有相同key的值 rdd.reduceByKey( ( x,y) => x+y ) { (1,2) , (3,10) }
groupByKey() 对具有相同key的值分组 rdd.groupByKey() { (1,2) , (3, [4,6] ) }
mapValues(f) 对键值对中的每个值(value)应用一个函数，但不改变键(key) rdd.mapValues(x => x+1) { (1,3) , (3,5) , (3,7) }
combineByKey( createCombiner, mergeValue, mergeCombiners, partitioner) 使用不同的返回类型合并具有相同键的值下面有详细讲解 -
flatMapValues(f) 对键值对RDD中每个值应用返回一个迭代器的函数，然后对每个元素生成一个对应的键值对。常用语符号化 rdd.flatMapValues(x => ( x to 5 ))
{ (1, 2) , (1, 3) , (1, 4) , (1, 5) , (3, 4) , (3, 5) }

keys() 获取所有key rdd.keys() {1,3,3}
values() 获取所有value rdd.values() {2,4,6}
sortByKey() 根据key排序 rdd.sortByKey() { (1,2) , (3,4) , (3,6) }
///

下表总结了针对两个键值对RDD的转化操作，以rdd1 = { (1,2) , (3,4) , (3,6) } rdd2 = { (3,9) } 为例，
///
函数名目的示例结果
subtractByKey 删掉rdd1中与rdd2的key相同的元素 rdd1.subtractByKey(rdd2) { (1,2) }
join 内连接 rdd1.join(rdd2)
{(3, (4, 9)), (3, (6, 9))}

leftOuterJoin 左外链接 rdd1.leftOuterJoin (rdd2)
{(3,( Some( 4), 9)), (3,( Some( 6), 9))}

rightOuterJoin 右外链接 rdd1.rightOuterJoin(rdd2)
{(1,( 2, None)), (3, (4, Some( 9))), (3, (6, Some( 9)))}

cogroup 将两个RDD钟相同key的数据分组到一起 rdd1.cogroup(rdd2) {(1,([ 2],[])), (3, ([4, 6],[ 9]))}

combineByKey
combineByKey( createCombiner, mergeValue, mergeCombiners, partitioner,mapSideCombine)

combineByKey( createCombiner, mergeValue, mergeCombiners, partitioner)

combineByKey( createCombiner, mergeValue, mergeCombiners)
函数功能：
聚合各分区的元素，而每个元素都是二元组。功能与基础RDD函数aggregate()差不多，可让用户返回与输入数据类型不同的返回值。
combineByKey函数的每个参数分别对应聚合操作的各个阶段。所以，理解此函数对Spark如何操作RDD会有很大帮助。
参数解析：
createCombiner：分区内创建组合函数
mergeValue：分区内合并值函数
mergeCombiners：多分区合并组合器函数
partitioner：自定义分区数，默认为HashPartitioner
mapSideCombine：是否在map端进行Combine操作，默认为true
工作流程：
combineByKey会遍历分区中的所有元素，因此每个元素的key要么没遇到过，要么和之前某个元素的key相同。
如果这是一个新的元素，函数会调用createCombiner创建那个key对应的累加器初始值。
如果这是一个在处理当前分区之前已经遇到的key，会调用mergeCombiners把该key累加器对应的当前value与这个新的value合并。

代码例子：
//统计男女个数

scala> val people = List(("男", "李四"), ("男", "张三"), ("女", "韩梅梅"), ("女", "李思思"), ("男", "马云"))
people: List[(String, String)] = List((男,李四), (男,张三), (女,韩梅梅), (女,李思思), (男,马云))

scala> val rdd = sc.parallelize(people,2)
rdd: org.apache.spark.rdd.RDD[(String, String)] = ParallelCollectionRDD[3] at parallelize at <console>:26

scala> val result = rdd.combineByKey(
     |      (x: String) => (List(x), 1),  //createCombiner
     |      (peo: (List[String], Int), x : String) => (x :: peo._1, peo._2 + 1), //mergeValue
     |      (sex1: (List[String], Int), sex2: (List[String], Int)) => (sex1._1 ::: sex2._1, sex1._2 + sex2._2))  //mergeCombiners
result: org.apache.spark.rdd.RDD[(String, (List[String], Int))] = ShuffledRDD[4] at combineByKey at <console>:25

scala> result.collect.foreach(println)
(男,(List(马云, 张三, 李四),3))
(女,(List(李思思, 韩梅梅),2))

流程分解：
在这里插入图片描述
解析：两个分区，分区一按顺序V1、V2、V3遍历

V1，发现第一个key=男时，调用createCombiner，即
(x: String) => (List(x), 1)
V2，第二次碰到key=男的元素，调用mergeValue，即
(peo: (List[String], Int), x : String) => (x :: peo._1, peo._2 + 1)
V3，发现第一个key=女，继续调用createCombiner，即
(x: String) => (List(x), 1)
… …
待各V1、V2分区都计算完后，数据进行混洗，调用mergeCombiners，即
(sex1: (List[String], Int), sex2: (List[String], Int)) => (sex1._1 ::: sex2._1, sex1._2 + sex2._2))

scala> val pairRDD=List(("Hadoop",1),("Spark",1),("Hive",1),("Spark",1))
pairRDD: List[(String, Int)] = List((Hadoop,1), (Spark,1), (Hive,1), (Spark,1))

scala> pairRDD.foreach(println)
(Hadoop,1)
(Spark,1)
(Hive,1)
(Spark,1)

reduceByKey(func)
reduceByKey(func)的功能是，使用func函数合并具有相同键的值。

比如，reduceByKey((a,b) => a+b)，有四个键值对(“spark”,1)、(“spark”,2)、(“hadoop”,3)和(“hadoop”,5)，对具有相同key的键值对进行合并后的结果就是：(“spark”,3)、(“hadoop”,8)。可以看出，(a,b) => a+b这个Lamda表达式中，a和b都是指value，比如，对于两个具有相同key的键值对(“spark”,1)、(“spark”,2)，a就是1，b就是2。

scala> val pRDD=sc.parallelize(pairRDD)
pRDD: org.apache.spark.rdd.RDD[(String, Int)] = ParallelCollectionRDD[0] at parallelize at <console>:26

scala> pRDD.reduceByKey((a,b)=>a+b).collect.foreach(println)
(Spark,2)                                                                       
(Hive,1)
(Hadoop,1)

groupByKey()
roupByKey()的功能是，对具有相同键的值进行分组。比如，对四个键值对(“spark”,1)、(“spark”,2)、(“hadoop”,3)和(“hadoop”,5)，采用groupByKey()后得到的结果是：(“spark”,(1,2))和(“hadoop”,(3,5))。

scala> pRDD.groupByKey()
res3: org.apache.spark.rdd.RDD[(String, Iterable[Int])] = ShuffledRDD[2] at groupByKey at <console>:26
//从上面执行结果信息中可以看出，分组后，value被保存到Iterable[Int]中

scala> pRDD.groupByKey().collect.foreach(println)
(Spark,CompactBuffer(1, 1))
(Hive,CompactBuffer(1))
(Hadoop,CompactBuffer(1))

keys
keys只会把键值对RDD中的key返回形成一个新的RDD。比如，对四个键值对(“spark”,1)、(“spark”,2)、(“hadoop”,3)和(“hadoop”,5)构成的RDD，采用keys后得到的结果是一个RDD[Int]，内容是{“spark”,“spark”,“hadoop”,“hadoop”}。

scala> pRDD.keys
res5: org.apache.spark.rdd.RDD[String] = MapPartitionsRDD[4] at keys at <console>:26

scala> pRDD.keys.foreach(println)
scala> pRDD.keys.collect.foreach(println)
Hadoop
Spark
Hive
Spark

values
values只会把键值对RDD中的value返回形成一个新的RDD。比如，对四个键值对(“spark”,1)、(“spark”,2)、(“hadoop”,3)和(“hadoop”,5)构成的RDD，采用keys后得到的结果是一个RDD[Int]，内容是{1,2,3,5}。

scala> pRDD.values
res8: org.apache.spark.rdd.RDD[Int] = MapPartitionsRDD[7] at values at <console>:26

scala> pRDD.values.collect.foreach(println)
1
1
1
1

sortByKey()
sortByKey()的功能是返回一个根据键排序的RDD。

scala> pRDD.sortByKey()
res10: org.apache.spark.rdd.RDD[(String, Int)] = ShuffledRDD[11] at sortByKey at <console>:26

scala> pRDD.sortByKey().foreach(println)

scala> pRDD.sortByKey().collect.foreach(println)
(Hadoop,1)
(Hive,1)
(Spark,1)
(Spark,1)

mapValues(func)
我们经常会遇到一种情形，我们只想对键值对RDD的value部分进行处理，而不是同时对key和value进行处理。对于这种情形，Spark提供了mapValues(func)，它的功能是，对键值对RDD中的每个value都应用一个函数，但是，key不会发生变化。比如，对四个键值对(“spark”,1)、(“spark”,2)、(“hadoop”,3)和(“hadoop”,5)构成的pairRDD，如果执行pairRDD.mapValues(x => x+1)，就会得到一个新的键值对RDD，它包含下面四个键值对(“spark”,2)、(“spark”,3)、(“hadoop”,4)和(“hadoop”,6)。

scala> pRDD.mapValues(x=>x+1)
res13: org.apache.spark.rdd.RDD[(String, Int)] = MapPartitionsRDD[18] at mapValues at <console>:26

scala> pRDD.mapValues(x=>x+1).collect.foreach(println)
(Hadoop,2)
(Spark,2)
(Hive,2)
(Spark,2)

join 内连接
join(连接)操作是键值对常用的操作。“连接”(join)这个概念来自于关系数据库领域，因此，join的类型也和关系数据库中的join一样，包括内连接(join)、左外连接(leftOuterJoin)、右外连接(rightOuterJoin)等。最常用的情形是内连接，所以，join就表示内连接。
对于内连接，对于给定的两个输入数据集(K,V1)和(K,V2)，只有在两个数据集中都存在的key才会被输出，最终得到一个(K,(V1,V2))类型的数据集。

比如，pairRDD1是一个键值对集合{(“spark”,1)、(“spark”,2)、(“hadoop”,3)和(“hadoop”,5)}，pairRDD2是一个键值对集合{(“spark”,“fast”)}，那么，pairRDD1.join(pairRDD2)的结果就是一个新的RDD，这个新的RDD是键值对集合{(“spark”,1,“fast”),(“spark”,2,“fast”)}。对于这个实例，我们下面在spark-shell中运行一下：

scala> val pairRDD1 = sc.parallelize(Array(("spark",1),("spark",2),("hadoop",3),("hadoop",5)))
pairRDD1: org.apache.spark.rdd.RDD[(String, Int)] = ParallelCollectionRDD[20] at parallelize at <console>:24

scala> val pairRDD2 = sc.parallelize(Array(("spark","fast")))
pairRDD2: org.apache.spark.rdd.RDD[(String, String)] = ParallelCollectionRDD[21] at parallelize at <console>:24

scala> pairRDD1.join(pairRDD2)
res15: org.apache.spark.rdd.RDD[(String, (Int, String))] = MapPartitionsRDD[24] at join at <console>:28

scala> pairRDD1.join(pairRDD2).foreach(println)
scala> pairRDD1.join(pairRDD2).collect.foreach(println)
(spark,(2,fast))
(spark,(1,fast))

subtractByKey 减运算

scala> pairRDD1.subtractByKey(pairRDD2).collect.foreach(println)
(hadoop,3)
(hadoop,5)

scala>  pairRDD1.subtractByKey(pairRDD2).reduceByKey((x,y)=>x+y).collect.foreach(println)
(hadoop,8)

leftOuterJoin 左外连接运算

scala> pairRDD1.leftOuterJoin(pairRDD2).collect.foreach(println)
(spark,(1,Some(fast)))
(spark,(2,Some(fast)))
(hadoop,(3,None))
(hadoop,(5,None))

rightOuterJoin 右外连接运算

scala> pairRDD1.rightOuterJoin(pairRDD2).collect.foreach(println)
(spark,(Some(2),fast))
(spark,(Some(1),fast))

cogroup 合并两个RDD中相同key的记录运算

scala> pairRDD1.cogroup(pairRDD2).collect.foreach(println)
(spark,(CompactBuffer(1, 2),CompactBuffer(fast)))
(hadoop,(CompactBuffer(5, 3),CompactBuffer()))

----the—end----

参考地址：
https://www.cnblogs.com/yongjian/p/6425772.html