RDD算子介绍（三）

weixin_46628668

已于 2024-03-29 22:01:45 修改

阅读量959

点赞数 25

文章标签： windows 服务器 linux

于 2024-03-20 22:54:48 首次发布

本文链接：https://blog.youkuaiyun.com/weixin_46628668/article/details/136889672

版权

本文介绍了ApacheSpark中RDD的几种关键操作，包括join用于合并具有相同键的RDD，cogroup用于将相同键的元素连接并组合，以及action算子如reduce、collect和各种统计方法。还探讨了WordCount的不同实现，以及RDD数据的保存方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1. join

将相同的key的值连接在一起，值的类型可以不同

val rdd1 : RDD[(String, Int)] = sc.makeRDD(List(("a", 1), ("b", 2), ("c", 3)))
val rdd2 : RDD[(String, Int)] = sc.makeRDD(List(("a", 4), ("b", 5), ("c", 6)))
val joinRDD : RDD[(String, (Int, Int))] = rdd1.join(rdd2)
joinRDD.collect().foreach(println)

如果有不同的key，则不会连接

val rdd1 : RDD[(String, Int)] = sc.makeRDD(List(("a", 1), ("b", 2), ("c", 3)))
val rdd2 : RDD[(String, Int)] = sc.makeRDD(List(("d", 4), ("c", 6), ("a", 4)))
val joinRDD : RDD[(String, (Int, Int))] = rdd1.join(rdd2)
joinRDD.collect().foreach(println)

相同的key有多个，则会两两匹配（笛卡尔乘积）

val rdd1 : RDD[(String, Int)] = sc.makeRDD(List(("a", 1), ("b", 2), ("c", 3)))
val rdd2 : RDD[(String, Int)] = sc.makeRDD(List(("a", 5), ("c", 6), ("a", 4)))
val joinRDD : RDD[(String, (Int, Int))] = rdd1.join(rdd2)
joinRDD.collect().foreach(println)

类似于SQL中的join，RDD中的join也会出现笛卡尔乘积，所以需要谨慎使用。同样类似于SQL，RDD也有leftOuterJoin和rightOuterJoin。

val rdd1 : RDD[(String, Int)] = sc.makeRDD(List(("a", 1), ("b", 2), ("c", 3)))
val rdd2 : RDD[(String, Int)] = sc.makeRDD(List(("a", 4), ("b", 5)))
val joinRDD : RDD[(String, (Int, Int))] = rdd1.leftOuterJoin(rdd2)
joinRDD.collect().foreach(println)

val rdd1 : RDD[(String, Int)] = sc.makeRDD(List(("a", 1), ("b", 2)))
val rdd2 : RDD[(String, Int)] = sc.makeRDD(List(("a", 4), ("b", 5), ("c", 6)))
val joinRDD : RDD[(String, (Int, Int))] = rdd1.rightOuterJoin(rdd2)
joinRDD.collect().foreach(println)

2. cogroup

congroup即connect+group，相同的key放在一个组里，然后连接在一起

val rdd1 : RDD[(String, Int)] = sc.makeRDD(List(("a", 1), ("b", 2)))
val rdd2 : RDD[(String, Int)] = sc.makeRDD(List(("a", 4), ("b", 5), ("c", 6)))
val cgRDD : RDD[(String, (Iterable[Int], Iterable[Int]))] = rdd1.cogroup(rdd2)
cgRDD.collect().foreach(println)

cogroup的参数可以不止一个rdd，最多可以有三个rdd

3. 案例实操：统计各个省份点击数前三的广告

val dataRDD = sc.textFile("data")

// 转换为((省份, 广告), 1)的格式
val mapRDD : RDD[((String, String), Int)] = dataRDD.map(line => {
    val datas = datas.split(" ")
    ((data(1), data(4)), 1)
})

// 聚合
val reduceRDD : RDD[((String, String), Int)] = mapRDD.reduceByKey(_+_)

// 转换为(省份, (广告, sum))的格式
val newMapRDD = reduceRDD.map{
    case((prv, ad), sum) => {
        (prv, (ad, sum))
    }
}

// 按照key（省份）分组
val groupRDD : RDD[(String, Iterable[(String, Int)])] = newMapRDD.groupByKey()

// 按照值的第二个参数降序排序，取前三
val resultRDD = groupRDD.mapValues(iter => {
    iter.toList.sortBy(_._2)(Ordering.Int.reverse)
}).take(3)

resultRDD.collect().foreach(println)

4. reduce

上述都是转换算子，接下来介绍行动算子。行动算子会触发作业的执行，底层调用的是runJob方法，会创建ActiveJob，并提交执行。

val rdd : RDD[Int] = sc.makeRDD(List(1, 2, 3, 4))
val i : Int = rdd.reduce(_+_)
println(i)

5. collect

将不同分区的数据按照分区的顺序采集到Driver端内存中，形成数组。

val rdd : RDD[Int] = sc.makeRDD(List(1, 2, 3, 4))
val i : Array[Int] = rdd.collect()
println(i.mkString(","))

6. count, first, take, takeOrdered

val rdd : RDD[Int] = sc.makeRDD(List(1, 2, 3, 4))
val i : Int = rdd.count()
println(i)

val first : Int = rdd.first()
println(first)

val takei : Array[Int]= rdd.take(3)
println(takei.mkString(","))

val rdd1 : RDD[Int] = sc.makeRDD(List(4, 2, 3, 1))
val takeOrderedi : Array[Int]= rdd1.takeOrdered(3)
println(takeOrderedi.mkString(","))

7. aggregate、fold

与aggregateByKey类似，传入初始值、分区内计算规则、分区间计算规则，得到计算结果。只不过aggregateByKey需要根据不同的key进行分组，最后得到的是RDD，而aggregate不需要根据key进行分组计算，直接得到计算结果。

val rdd : RDD[Int] = sc.makeRDD(List(1, 2, 3, 4))
val result : Int = rdd.aggregate(0)(_+_, _+_)
println(result)

另外一个区别就是aggregate的初始值不进会参与分区内计算，还会参与分区间计算，而aggregateByKey的初始值只参与分区内计算，所以下面程序的允许结果为40

val rdd : RDD[Int] = sc.makeRDD(List(1, 2, 3, 4))
val result : Int = rdd.aggregate(10)(_+_, _+_)
println(result)

如果分区内计算规则和分区间计算规则相同，可以使用fold简化

val rdd : RDD[Int] = sc.makeRDD(List(1, 2, 3, 4))
val result : Int = rdd.fold(10)(_+_)
println(result)

8. countByKey、countByValue

val rdd : RDD[Int] = sc.makeRDD(List(1, 2, 3, 4), 2)
val result : collection.Map[Int, Long] = rdd.countByValue()
println(result)

表示4出现了1次，2出现了1次，1出现了1次，3出现了1次。

val rdd = sc.makeRDD(List(("a", 1), ("a", 1), ("a", 1)))
val result : collection.Map[String, Long] = rdd.countByKey()
println(result)

按照key统计次数，跟值无关，这里a出现了3次。

9. WordCount的多种实现方式

val rdd = sc.makeRDD(List("Hello Scala", "Hello Scala"))
val words : RDD[String] = rdd.flatMap(_.split(" "))
val group : RDD[(String, Iterable[String])] = words.groupBy(word=>word)
val wordCount : RDD[(String, Int)] = group.mapValues(iter=>iter.size)

val rdd = sc.makeRDD(List("Hello Scala", "Hello Scala"))
val words : RDD[String] = rdd.flatMap(_.split(" "))
val wordOne = words.map((_, 1))
val group : RDD[(String, Iterable[Int])] = wordOne.groupByKey()
val wordCount : RDD[(String, Int)] = group.mapValues(iter=>iter.size)

val rdd = sc.makeRDD(List("Hello Scala", "Hello Scala"))
val words : RDD[String] = rdd.flatMap(_.split(" "))
val wordOne = words.map((_, 1))
val wordCount : RDD[(String, Int)] = wordOne.reduceByKey()

val rdd = sc.makeRDD(List("Hello Scala", "Hello Scala"))
val words : RDD[String] = rdd.flatMap(_.split(" "))
val wordOne = words.map((_, 1))
val wordCount : RDD[(String, Int)] = wordOne.aggregateByKey(0)(_+_, _+_)

val rdd = sc.makeRDD(List("Hello Scala", "Hello Scala"))
val words : RDD[String] = rdd.flatMap(_.split(" "))
val wordOne = words.map((_, 1))
val wordCount : RDD[(String, Int)] = wordOne.combineByKey(v=>v)((x : Int, y : Int) => x + y, (x : Int, y : Int) => x + y)

val rdd = sc.makeRDD(List("Hello Scala", "Hello Scala"))
val words : RDD[String] = rdd.flatMap(_.split(" "))
val wordOne = words.map((_, 1))
val wordCount : collection.Map[String, Long] = wordOne.countByKey()

val rdd = sc.makeRDD(List("Hello Scala", "Hello Scala"))
val words : RDD[String] = rdd.flatMap(_.split(" "))
val wordCount : collection.Map[String, Long] = words.countByValue()

val rdd = sc.makeRDD(List("Hello Scala", "Hello Scala"))
val words : RDD[String] = rdd.flatMap(_.split(" "))
val wordMap = word.map(word => {
    mutable.Map[String, Int]((word, 1))
})
val wordCount = wordMap.reduce((map1, map2) => {
    map2.foreach{
        case(word, count) => {
            val newCount = map1.getOrElse(word, 0L) + count
            map1.update(word, newCount)
        }
    }
    map1
})