键值对转换算子2
1. sortByKey
- 定义:sortByKey([ascending], [numPartitions])
- 解释:按照key值对RDD进行排序,返回一个排序完成RDD
ascending: boolean(true:升序 false:降序)
numPartitions: 分区个数 - 案例:
def sortByKeyOpt(sc: SparkContext): Unit = {
val rdd:RDD[(String,Int)] = sc.makeRDD(Array(("zs",20),("ls",30),("ww",40),("zl",40),("zs",40)))
val rdd1:RDD[(String,Int)] = rdd.sortByKey(false)
rdd1.foreach(println(_))
/*
(zs,20)
(zs,40)
(zl,40)
(ww,40)
(ls,30)
*/
}
2. join
- 定义:join(otherDataset, [numPartitions])
- 解释:将两个键值对类型RDD按照相同的key值将不同rdd的value数据整合一下
(K,V) (K,W)===>(K,(V,W)),而且只会保留两个RDD中key值相同的数据,key值不相同的数据舍弃,传入的另外一个键值对类型的RDD有要求,key值必须和当前RDD的key值类型一致,value类型可以不一致 - 案例:
def joinOpt(sc: SparkContext): Unit = {
println("----------------join开始------------------")
val rdd:RDD[(String,Int)] = sc.makeRDD(Array(("zs",20),("ls",30),("ww",40),("zl",40),("zs",40)))
val rdd2:RDD[(String,String)] = sc.makeRDD(Array(("ls","女"),("zs","男"),("zs","女"),("ww","男"),("wb","男")))
val rdd3:RDD[(String,(Int,String))] = rdd.join(rdd2)
rdd3.foreach(println(_))
/*
(ls,(30,女))
(ww,(40,男))
(zs,(20,男))
(zs,(20,女))
(zs,(40,男))
(zs,(40,女))
*/
println("----------------join结束------------------")
}
3. leftOuterJoin
- 定义:(K,(V,Option[W]))
- 解释:和join类似,只不过保留左边RDD的所有数据,括号里面的RDD只保留匹配数据
- 案例:
def leftOuterJoinOpt(sc: SparkContext): Unit = {
println("----------------leftOuterJoin开始------------------")
val rdd:RDD[(String,Int)] = sc.makeRDD(Array(("zs",20),("ls",30),("ww",40),("zl",40),("zs",40)))
val rdd2:RDD[(String,String)] = sc.makeRDD(Array(("ls","女"),("zs","男"),("zs","女"),("ww","男"),("wb","男")))
val leftJoin: RDD[(String, (Int, Option[String]))] = rdd.leftOuterJoin(rdd2)
leftJoin.foreach(println(_))
/*
(ls,(30,Some(女)))
(zl,(40,None))
(ww,(40,Some(男)))
(zs,(20,Some(男)))
(zs,(20,Some(女)))
(zs,(40,Some(男)))
(zs,(40,Some(女)))
*/
println("----------------leftOuterJoin结束------------------")
}
4. rightOuterJoin
- 定义:(K,(Option[V],W))
- 解释:和join类似,只不过保留右边RDD的所有数据,左边的RDD只保留匹配(key来匹配)数据
- 案例:
def rightOuterJoinOpt(sc: SparkContext): Unit = {
println("----------------rightOuterJoin开始------------------")
val rdd:RDD[(String,Int)] = sc.makeRDD(Array(("zs",20),("ls",30),("ww",40),("zl",40),("zs",40)))
val rdd2:RDD[(String,String)] = sc.makeRDD(Array(("ls","女"),("zs","男"),("zs","女"),("ww","男"),("wb","男")))
val rightJoin: RDD[(String, (Option[Int], String))] = rdd.rightOuterJoin(rdd2)
rightJoin.foreach(println(_))
/*
(ls,(Some(30),女))
(ww,(Some(40),男))
(zs,(Some(20),男))
(zs,(Some(20),女))
(zs,(Some(40),男))
(zs,(Some(40),女))
(wb,(None,男))
*/
println("----------------rightOuterJoin结束------------------")
}
说明
如果在两个RDD中有重复性的数据出现,出现笛卡尔乘积的情况
5. cogroup
- 定义:cogroup(otherDataset, [numPartitions])
- 解释:将两个键值对类型的RDD按照key值聚合value。将每一个RDD的key值相同的value数据聚合成为一个迭代器Iterable[V]
最终返回如下的一个RDD ,RDD【(key,(Iterable[V],Iterable[W]))】 - 案例:
def cogroupOpt(sc: SparkContext): Unit = {
println("----------------join开始------------------")
val rdd:RDD[(String,Int)] = sc.makeRDD(Array(("zs",20),("ls",30),("ww",40),("zl",40),("zs",40)))
val rdd2:RDD[(String,String)] = sc.makeRDD(Array(("ls","女"),("zs","男"),("zs","女"),("ww","男"),("wb","男")))
val cogroup: RDD[(String, (Iterable[Int], Iterable[String]))] = rdd.cogroup(rdd2)
cogroup.foreach(tuple => {
println(s"key= ${tuple._1} , value1 = ${tuple._2._1} , value2 = ${tuple._2._2}")
})
/*
key= ls , value1 = CompactBuffer(30) , value2 = CompactBuffer(女)
key= zl , value1 = CompactBuffer(40) , value2 = CompactBuffer()
key= ww , value1 = CompactBuffer(40) , value2 = CompactBuffer(男)
key= zs , value1 = CompactBuffer(20, 40) , value2 = CompactBuffer(男, 女)
key= wb , value1 = CompactBuffer() , value2 = CompactBuffer(男)
*/
println("----------------join结束------------------")
}
6.subtractByKey
- 定义:subtractByKey(otherDataSet)
- 解释: 删除前面RDD中与括号传入的RDDkey值相同的元素,返回的是前者RDD删除完成的数据
- 案例:
def subtractByKeyOpt(sc: SparkContext): Unit = {
println("----------------join开始------------------")
val rdd:RDD[(String,Int)] = sc.makeRDD(Array(("zs",20),("ls",30),("ww",40),("zl",40),("zs",40)))
val rdd2:RDD[(String,String)] = sc.makeRDD(Array(("ls","女"),("zs","男"),("zs","女"),("ww","男"),("wb","男")))
val rdd7:RDD[(String,Int)] = rdd.subtractByKey(rdd2)
rdd7.foreach(println(_)) // (zl,40)
println("----------------join结束------------------")
}
7. keys
- 定义:keys :RDD[key]
- 解释:将键值对类型RDD中的所有key值取出来形成一个新的RDD
- 案例:
def keysOpt(sc: SparkContext): Unit = {
println("----------------join开始------------------")
val rdd:RDD[(String,Int)] = sc.makeRDD(Array(("zs",20),("ls",30),("ww",40),("zl",40),("zs",40)))
val keys: RDD[String] = rdd.keys
keys.foreach(println(_)) // zs ls ww zl zs
println("----------------join结束------------------")
}
8. values
- 定义:values:RDD[value]
- 解释:将键值对类型RDD中的所有value值取出来形成一个新的RDD
- 案例:
def valuesOpt(sc: SparkContext): Unit = {
println("----------------join开始------------------")
val rdd:RDD[(String,Int)] = sc.makeRDD(Array(("zs",20),("ls",30),("ww",40),("zl",40),("zs",40)))
val values = rdd.values
values.foreach(println(_)) // 20 30 40 40 40
println("----------------join结束------------------")
}
9.mapValues(func)
- 定义:func(T)=>U 返回值:RDD[(key,U)]
- 解释:对键值对RDD中所有values数据应用一个func函数,代表对每一个value数据做一个操作 返回一个新的RDD
- 案例:
def mapValuesOpt(sc: SparkContext): Unit = {
println("----------------mapValues开始------------------")
val rdd:RDD[(String,Int)] = sc.makeRDD(Array(("zs",20),("ls",30),("ww",40),("zl",40),("zs",40)))
val value = rdd.mapValues(_ + 1)
/*
(zs,21)
(ls,31)
(ww,41)
(zl,41)
(zs,41)
*/
value.foreach(println(_))
println("----------------mapValues结束------------------")
}
本文来自博客园,作者:jsqup,转载请注明原文链接:https://www.cnblogs.com/jsqup/p/16619496.html