键值对转换算子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结束------------------")
}