目录
一、RDD操作
转载：https://www.cnblogs.com/nolonely/p/5402698.html
1.对一个数据为{1，2，3，3}的RDD进行基本的RDD转化操作
| 函数名 | 目的 | 示例 | 结果 |
| map() |
函数应用于RDD中的每个元素 | rdd.map(x=>x+1) | {2,3,4,4} |
| flatMap() | 将函数应用于RDD中的每个怨毒，通常用来切分单词 | rdd.flatMap(x=>x.to(3)) | {1,2,3,2,3,3,3} |
| filter() | 返回一个通过传给filter()的函数的元素组成的RDD | rdd.filter(x=>x!=1) | {2,3,3} |
| distinct() | 去重 | rdd.distinct() | {1,2,3} |
| sample(withReplacement,fraction,[seed]) | 对RDD进行采样，以及是否替换 | rdd.sample(false,0.5) | 非确定 |
2.对数据分别为{1，2，3}和{3，4，5}的RDD进行针对两个RDD的转化操作
| 函数名 | 目的 | 示例 | 结果 |
| union() | 生成一个包含两个RDD中所有元素的RDD | rdd.union(other) | {1,2,3,3,4,5} |
| intersection() | 求两个RDD共同的元素RDD | rdd.intersection(other) | {3} |
| subtract() | 移除一个元素的内容 | rdd.subtract(other) | {1,2} |
| cartesian() | 与另一个RDD的笛卡儿积 | rdd.cartesian(other) | {(1,3),(1,4)...(3,5)} |
3.对一个数据为{1，2，3，3}的RDD进行基本的RDD行动操作
| 函数名 | 目的 | 示例 | 结果 |
| collect() | 所有元素 | rdd.collect() | {1,2,3,3} |
| count() | 元素个数 | rdd.count() | 4 |
| countByValue() | 各元素在rdd中出现的次数 | rdd.countByValue() | {(1,1),(2,1),(3,2)} |
| take(num) | 从rdd中返回num个元素 | rdd.take(2) | {1,2} |
| top(num) | 从rdd中返回最前面的num个元素 | rdd.top(2) | {3,3} |
| takeOrdered(num)(ordering) | 按提供的顺序，返回最前面的怒骂个元素 | rdd.takeOrdered(2)(myOrdering) | {3,3} |
| takeSample(withReplacement,num,[seed]) | 从rdd中返回任意一些元素 | rdd.takeSample(false,1) | 非确定的 |
| reduce(func) | 冰雷整合RDD中的所有数据 | rdd.reduce((x,y)=>x+y) | 9 |
| fold(zero)(func) | 和reduce一样，但是需要初始值 | rdd.fold(0)((x,y)=>x+y) | 9 |
| aggregate(zeroValue)(seqOp,combOp) | 和reduce()相似，但是通常返回不同类型的函数 | rdd.aggregate((0,0))((x,y)=>(x,y)=>(x._1+y,x._2+1),(x,y)=>(x._1+y._1,x._2+y._2)) |
(9,4) |
| foreach(func) | 对RDd中的每个元素使用给定的元素 | rdd.foreach(func) | 无 |
键值对操作
4.pair RDD的转化操作(以键值对集合{(1,2),(3,4),(3,6)}为例)
| 函数名 | 目的 | 示例 | 结果 |
| reduceByKey(func) | 合并具有相同键的值 | rdd.reduceByKey((x,y)=>x+y) | {(1,2),(3,10)} |
| groupByKey() | 对具有相同键的值进行分组 | rdd.groupByKey() | {(1,[2]),(3,[4,6])} |
| combineByKey(createCombiner,mergeCombiners,partitioner) | 使用不同的返回类型合并具有相同键的值 | ||
| mapValue(func) | 对pairRDD中的每个值应用一个函数而不改变键 | rdd.mapValues(x=>x+1) | {(1,3),(3,5),(3,7)} |
| flatMapValues() | 对pairRDD中的每个值应用一个返回迭代器的函数，然后返回的每个元素都生成一个对应原键的键值对记录，通常用于符号化 | rdd.flatMapValues(x=>(x to 5)) | {(1,2),(1,3),(1,4),(1,5),(3,4),(3,5)} |
| keys() | 返回一个仅包含键的RDD | rdd.keys() | {1,3,3} |
| values() | 返回一个仅包含值的RDD | rdd.values() | {2,4,6} |
| sortByKey() | 返回一个根据键排序的RDD | rdd.sortByKey() | {(1,2),(3,4),(3,6)} |
针对两个pairRDD的转换操作(rdd={(1,2),(3,4),(3,6)} other={(3,9)})
| 函数名 | 目的 | 示例 | 结果 |
| subtractByKey | 删掉RDD中的键与otherRDD中的键相同的元素 | rdd.subtractByKey(other) | {(1,2)} |
| join | 对两个rdd进行内链接 | rdd.join(other) | {(3,(Some(4),9)),(3,(Some(6),9))} |
| rightOuterJoin | 连接操作，确保第一个rdd的键必须存在(右外连接) | rdd.rightOuterJoin(other) | {(3,(4,Some(9))),(3,(4,Some(9)))} |
| leftOutrtJoin | 连接操作，确保第二个rdd的键必须存在(左外连接) | rdd.leftOuterJoin(other) | {(1,(2,None)),(3,(4,Some(9))),(3,(6,Some(9)))} |
| cogroup | 将两个rdd中拥有相同键的数据分组到一起 | rdd.cogroup(other) | {(1,([2],[])),(3,([4,6],[9]))} |
5.PairRDD 的行动操作（以键值对集合{(1,2),(3,4),(3,6)}）
| 函数 | 描述 | 示例 | 结果 |
| countByKey() | 对每个键对应的元素分别计数 | rdd.countByKey() | {(1,1),(3,2)} |
| collectAsMap() | 将结果以映射表的形式返回，以便查询 | rdd.collectAsMap() | Mqp{(1,2),(3,4),(3,6)} |
| lookup(key) | 返回给定键对应的所有值 | rdd.lookup(3) | [4,6] |
二、Spark 键值对RDD操作
转载：https://www.cnblogs.com/yongjian/p/6425772.html
概述
键值对RDD是Spark操作中最常用的RDD，它是很多程序的构成要素，因为他们提供了并行操作各个键或跨界点重新进行数据分组的操作接口。
创建
Spark中有许多中创建键值对RDD的方式，其中包括
- 文件读取时直接返回键值对RDD
- 通过List创建键值对RDD
在Scala中，可通过Map函数生成二元组
| 1 2 3 4 5 6 7 8 9 10 |
|
键值对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) } |
| combineBy Key( 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合并。
代码例子：
//统计男女个数
| 1 2 3 4 5 6 7 8 9 10 |
|
结果
(男, ( 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))
以下例子都基于此RDD
| 1 2 3 4 |
|
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。
| 1 2 3 4 |
|
groupByKey()
roupByKey()的功能是，对具有相同键的值进行分组。比如，对四个键值对("spark",1)、("spark",2)、("hadoop",3)和("hadoop",5)，采用groupByKey()后得到的结果是：("spark",(1,2))和("hadoop",(3,5))。
| 1 2 3 4 5 6 7 |
|
keys
keys只会把键值对RDD中的key返回形成一个新的RDD。比如，对四个键值对("spark",1)、("spark",2)、("hadoop",3)和("hadoop",5)构成的RDD，采用keys后得到的结果是一个RDD[Int]，内容是{"spark","spark","hadoop","hadoop"}。
| 1 2 3 4 5 6 7 |
|
values
values只会把键值对RDD中的value返回形成一个新的RDD。比如，对四个键值对("spark",1)、("spark",2)、("hadoop",3)和("hadoop",5)构成的RDD，采用keys后得到的结果是一个RDD[Int]，内容是{1,2,3,5}。
| 1 2 3 4 5 6 7 8 |
1 |
sortByKey()
sortByKey()的功能是返回一个根据键排序的RDD。
| 1 2 3 4 5 6 7 |
|
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)。
| 1 2 3 4 5 6 7 |
|
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中运行一下：
| 1 2 3 4 5 6 7 8 9 10 11 12 |
|
详细请参考《Spark快速大数据分析》
