spark学习-rdd算子_rdd 18(1)

2401_84185397

于 2024-04-30 04:38:05 发布

阅读量685

点赞数 7

分类专栏：程序员文章标签： spark 学习 windows

本文链接：https://blog.csdn.net/2401_84185397/article/details/138332033

版权

程序员专栏收录该内容

117 篇文章 0 订阅

订阅专栏

5.glom:把同一个分区的数据放到同一个数组内

    //    1.从集合中获取数据
    val rdd: RDD[Any] = sparkContext.makeRDD(List((1,2), "2", 3, 4), 2)
    //    使用glom把个体合并成整体，同一个分区的数据放到同一个数组内
   val glomrdd: RDD[Array[Any]] = rdd.glom()
    //    输出 如果直接println输出的是数组内的数组，而不是其中的数据
    glomrdd.collect().foreach(s=>{
      s.foreach(println)
    })
    println("========0号分区数据=========")
   println(glomrdd.collect()(0).mkString(","))
    println("========1号分区数据=========")
    println(glomrdd.collect()(1).mkString(","))

6.groupBy:把数据根据指定的规则进行分组

可以根据单词的首字母进行分组，返回数据的类型是：元组，元组内是分组依据和可迭代对象：（key,可迭代对象）

    //    1.从集合中获取数据
    val rdd = sparkContext.makeRDD(List("hello","world","spark","honest"))
//2.使用groupby把首字母相同的放入同一个分组中
val groupbyrdd: RDD[(Char, Iterable[String])] = rdd.groupBy(
  num => {
    num.charAt(0)
  }
)

7.filter()根据指定规则过滤出数据

过滤出list内的奇数

    //    1.从集合中获取数据
    val rdd: RDD[Int] = sparkContext.makeRDD(List(1, 2, 3, 4))
    val filterrdd: RDD[Int] = rdd.filter(
      nums => nums % 2 != 0
    )

8.sample:根据指定的规则从数据集中抽取数据

第一个参数boolean表示是否抽取元素是否放回，如果放回表示一个元素可能重复出现

第二个参数表示每个元素被抽取到的概率，范围是[ 0,1]

第三个参数表示随机种子数，输入一个正整数

实现原理：根据种子和随机算法算出一个数和第二个参数设置几率比较，小于第二个参数要，大于第二个参数则不要

    //    1.从集合中获取数据
    val rdd: RDD[Int] = sparkContext.makeRDD(List(1, 2, 3, 4))
    val samplerdd: RDD[Int] = rdd.sample(
      false, 0.5
    )

9.distinct:去除数据集中重复的元素,可以指定新生成的RDD的分区数

val distinctRDD = originalRDD.distinct([numPartitions])

numPartitions用于指定分区数

10.coalesce:用于合并分区减少分区的数量

val conf = new SparkConf().setAppName("CoalesceExample").setMaster("local")
val sc = new SparkContext(conf)

val data = sc.parallelize(1 to 10, 5) // 创建5个分区的RDD
val coalescedData = data.coalesce(2) // 合并成两个分区

11.repartition:可以增加或者减少分区数量

def repartition(numPartitions: Int)(implicit ord: Ordering[T] = null): RDD[T]

12.sortBy用于排序数据

val sortedRDD = originalRDD.sortBy(func, ascending = true, numPartitions)

// func用于指定排序的依据
//ascending如果指定为true的话就是升序，false是降序
//numPartitions用来指定排序后的RDD数量，不写的话默认是原有RDD的分区数

双value类型

13.intersection：求两个RDD的数据交集

val dataRDD1 = sparkContext.makeRDD(List(1,2,3,4))
val dataRDD2 = sparkContext.makeRDD(List(3,4,5,6))
val dataRDD = dataRDD1.intersection(dataRDD2)

14.union：求两个RDD数据的并集

val dataRDD1 = sparkContext.makeRDD(List(1,2,3,4))
val dataRDD2 = sparkContext.makeRDD(List(3,4,5,6))
val dataRDD = dataRDD1.union(dataRDD2)

15.subtract：去除两个RDD的数据的重复部分，保留其他数据

val dataRDD1 = sparkContext.makeRDD(List(1,2,3,4))
val dataRDD2 = sparkContext.makeRDD(List(3,4,5,6))
val dataRDD = dataRDD1.subtract(dataRDD2)

16.zip

将两个 RDD 中的元素，以键值对的形式进行合并。其中，键值对中的 Key 为第 1 个 RDD 中的元素，Value 为第 2 个 RDD 中的相同位置的元素。

val dataRDD1 = sparkContext.makeRDD(List(1,2,3,4))
val dataRDD2 = sparkContext.makeRDD(List(3,4,5,6))
val dataRDD = dataRDD1.zip(dataRDD2)

key-value类型

17.partitionBy

将数据按照指定 Partitioner 重新进行分区。Spark 默认的分区器是 HashPartitioner(分区数量)

    val rdd = sparkContext.makeRDD(List((1,1),(2,1),(3,1),(4,1)),2)
rdd.partitionBy(new HashPartitioner(2))

HashPartitioner是根据key的哈希码与分区数进行取余，根据取余的结果来对数据进行分区。

返回数据类型是一个元组.

18.reduceByKey:按照相同的key对value进行聚合

def reduceByKey(func: (V, V) => V, numPartitions: Int): RDD[(K, V)]

可以指定聚合后的分区数量，默认是原RDD的分区数，返回值类型是元组

19.groupByKey:将数据源的数据根据 key 对 value 进行分组

val dataRDD1 =
 sparkContext.makeRDD(List(("a",1),("b",2),("c",3)))
val dataRDD2 = dataRDD1.groupByKey()
//指定分区数量是2
val dataRDD3 = dataRDD1.groupByKey(2)
//指定分区规则
val dataRDD4 = dataRDD1.groupByKey(new HashPartitioner(2))

20.aggregateByKey:将数据根据不同的规则进行分区内计算和分区间计算

val dataRDD1 =
 sparkContext.makeRDD(List(("a",1),("b",2),("c",3)))
val dataRDD2 =
 dataRDD1.aggregateByKey(0)(_+_,_*_)

第一个括号内表示的是初始值（初始值决定了返回的数据类型），第二个括号内第一个参数表示分区内进行的操作，第二个参数表示分区间进行的操作，分区内和分区间的操作可以相同也可以不同。

21.foldByKey:当aggregateByKey分区内和分区间操作相同时就是foldByKey

val dataRDD1 = sparkContext.makeRDD(List(("a",1),("b",2),("c",3)))
val dataRDD2 = dataRDD1.foldByKey(0)(_+_)

22.combineByKey:有3个参数，第一个参数表示value的格式，第二个参数表示相同key的value在分区内进行的操作，第三个参数表示相同key的value在分区间进行的操作

    //    1.从集合中获取数据，求每个k对应数据的平均值
    val rdd: RDD[(String, Int)] = sparkContext.makeRDD(List(("a", 1), ("a"  , 2), ("b", 3), ("b", 4), ("b", 5), ("a", 6)))
    val combinrdd: RDD[(String, (Int, Int))] = rdd.combineByKey(
//   v代表原始RDD内的value,1代表出现的次数
      v => (v, 1),
//   分区内进行 操作
      (t: (Int, Int), v) => {
 //    (相同key的value值相加，记录出现次数)
        (t._1 + v, t._2 + 1)
      }
      ,
      (t1: (Int, Int), t2: (Int, Int)) => {
        (t1._1 + t2._1, t1._2 + t2._2)
      }
    )

23.sortByKey:按照key对数据进行升序或者降序

def sortByKey(ascending: Boolean = true, numPartitions: Int = self.partitions.length)
 : RDD[(K, V)]

val dataRDD1 = sparkContext.makeRDD(List(("a",1),("b",2),("c",3)))
val sortRDD1: RDD[(String, Int)] = dataRDD1.sortByKey(true)
val sortRDD1: RDD[(String, Int)] = dataRDD1.sortByKey(false)

24.join

在类型为(K,V)和(K,W)的 RDD 上调用，返回一个相同 key 对应的所有元素连接在一起的 (K,(V,W))的 RDD

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

25.leftOuterJoin:左外连接

val dataRDD1 = sparkContext.makeRDD(List(("a",1),("b",2),("c",3)))
val dataRDD2 = sparkContext.makeRDD(List(("a",1),("b",2),("c",3)))
val rdd: RDD[(String, (Int, Option[Int]))] = dataRDD1.leftOuterJoin(dataRDD2)

26.cogroup

在类型为(K,V)和(K,W)的 RDD 上调用，返回一个(K,(Iterable,Iterable))类型的 RDD

val dataRDD1 = sparkContext.makeRDD(List(("a",1),("a",2),("c",3)))
val dataRDD2 = sparkContext.makeRDD(List(("a",1),("c",2),("c",3)))
val value: RDD[(String, (Iterable[Int], Iterable[Int]))] = 
dataRDD1.cogroup(dataRDD2)

行动算子

1.reduce：先聚合分区内，再聚合分区间

val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4)) // 聚合数据 
val reduceResult: Int = rdd.reduce(_+_)

2.collect:以数组形式返回RDD内的数据

val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4))
// 收集数据到 Driver
rdd.collect().foreach(println)

3.count：返回RDD内的元素个数

val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4))
// 返回 RDD 中元素的个数
val countResult: Long = rdd.count()

4.first:返回RDD内的第一个元素

val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4))
// 返回 RDD 中元素的个数
val firstResult: Int = rdd.first()
println(firstResult)

5.take:返回一个由前n个元素组成的数组

vval rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4))
// 返回 RDD 中元素的个数
val takeResult: Array[Int] = rdd.take(2)
println(takeResult.mkString(","))

6.takeOrdered:返回RDD排序后的前n个元素

val rdd: RDD[Int] = sc.makeRDD(List(1,3,2,4))
// 返回 RDD 中元素的个数，默认是升序
val result: Array[Int] = rdd.takeOrdered(2)
//降序
val ints1= rdd.takeOrdered(3)(Ordering[Int].reverse)

7.aggregate:分区的数据通过初始值和分区内的数据进行聚合，然后再和初始值进行分区间的数据聚合

val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4), 8)
// 将该 RDD 所有元素相加得到结果
//val result: Int = rdd.aggregate(0)(_ + _, _ + _)
val result: Int = rdd.aggregate(10)(_ + _, _ + _)

8.countByKey:统计每种key的个数

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

需要这份系统化资料的朋友，可以戳这里获取

rdd.aggregate(10)(_ + _, _ + _)


#### 8.countByKey:统计每种key的个数


[外链图片转存中...(img-jFHoD000-1714423048417)]
[外链图片转存中...(img-EtMtkotl-1714423048417)]
[外链图片转存中...(img-lbNekTKp-1714423048417)]

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618545628)**

2401_84185397

关注

7
点赞
踩
13

收藏

觉得还不错? 一键收藏
0
评论
spark学习-rdd算子_rdd 18(1)

其中，键值对中的 Key 为第 1 个 RDD 中的元素，Value 为第 2 个 RDD 中的相同位置的元素。在类型为(K,V)和(K,W)的 RDD 上调用，返回一个相同 key 对应的所有元素连接在一起的 (K,(V,W))的 RDD。），第二个括号内第一个参数表示分区内进行的操作，第二个参数表示分区间进行的操作，分区内和分区间的操作可以相同也可以不同。在类型为(K,V)和(K,W)的 RDD 上调用，返回一个(K,(Iterable,Iterable))类型的 RDD。第一个括号内表示的是初始值（
复制链接

扫一扫