RDD算子2

最新推荐文章于 2025-04-12 14:16:25 发布
原创 最新推荐文章于 2025-04-12 14:16:25 发布 · 215 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#spark #RDD

本文通过一系列示例展示了Apache Spark中RDD的基本操作和高级功能，包括数据分区、聚合操作、键值对处理、集合操作等，帮助读者深入理解Spark RDD API的使用方法。

http://homepage.cs.latrobe.edu.au/zhe/ZhenHeSparkRDDAPIExamples.html

http://homepage.cs.latrobe.edu.au/zhe/ZhenHeSparkRDDAPIExamples.html

//让我们先用分区标签打印出RDD的内容
scala> val z = sc.parallelize(List(1,2,3,4,5,6), 2)
z: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[0] at parallelize at <console>:24

scala> def myfunc(index: Int, iter: Iterator[(Int)]) : Iterator[String] = {
     |   iter.map(x => "[partID:" +  index + ", val: " + x + "]")
     | }
myfunc: (index: Int, iter: Iterator[Int])Iterator[String]

scala> z.mapPartitionsWithIndex(myfunc).collect
res0: Array[String] = Array([partID:0, val: 1], [partID:0, val: 2], [partID:0, val: 3], [partID:1, val: 4], [partID:1, val: 5], [partID:1, val: 6])

scala> z.aggregate(0)(math.max(_, _), _ + _)
res1: Int = 9                                                                   

scala> z.aggregate(5)(math.max(_, _), _ + _)
res2: Int = 16

scala> val z = sc.parallelize(List("a","b","c","d","e","f"),2)
z: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[2] at parallelize at <console>:24

scala> def myfunc(index: Int, iter: Iterator[(String)]) : Iterator[String] = {
     |   iter.map(x => "[partID:" +  index + ", val: " + x + "]")
     | }
myfunc: (index: Int, iter: Iterator[String])Iterator[String]

scala> z.mapPartitionsWithIndex(myfunc).collect
res3: Array[String] = Array([partID:0, val: a], [partID:0, val: b], [partID:0, val: c], [partID:1, val: d], [partID:1, val: e], [partID:1, val: f])

scala> z.aggregate("")(_ + _, _+_)
res4: String = defabc

scala> z.aggregate("")(_ + _, _+_)
res5: String = defabc

scala> z.aggregate("")(_ + _, _+_)
res6: String = defabc

scala> z.aggregate("x")(_ + _, _+_)
res7: String = xxabcxdef

scala> val z = sc.parallelize(List("12","23","345","4567"),2)
z: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[4] at parallelize at <console>:24

scala> z.aggregate("")((x,y) => math.max(x.length, y.length).toString, (x,y) => x + y)
res8: String = 42

scala> z.aggregate("")((x,y) => math.max(x.length, y.length).toString, (x,y) => x + y)
res9: String = 42

scala> z.aggregate("")((x,y) => math.max(x.length, y.length).toString, (x,y) => x + y)
res10: String = 24

scala> z.aggregate("")((x,y) => math.min(x.length, y.length).toString, (x,y) => x + y)
res11: String = 11

scala> z.aggregate("")((x,y) => math.min(x.length, y.length).toString, (x,y) => x + y)
res12: String = 11

scala> z.aggregate("")((x,y) => math.min(x.length, y.length).toString, (x,y) => x + y)
res13: String = 11

scala> val z = sc.parallelize(List("12","23","345",""),2)
z: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[5] at parallelize at <console>:24

scala> z.aggregate("")((x,y) => math.min(x.length, y.length).toString, (x,y) => x + y)
res14: String = 10

scala> z.aggregate("")((x,y) => math.min(x.length, y.length).toString, (x,y) => x + y)
res15: String = 10

scala> z.aggregate("")((x,y) => math.min(x.length, y.length).toString, (x,y) => x + y)
res16: String = 10

scala> z.aggregate("")((x,y) => math.min(x.length, y.length).toString, (x,y) => x + y)
res17: String = 01

scala> val z = sc.parallelize(List("12","23","","345"),2)
z: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[6] at parallelize at <console>:24

scala> z.aggregate("")((x,y) => math.min(x.length, y.length).toString, (x,y) => x + y)
res18: String = 11                                                              

scala> val pairRDD = sc.parallelize(List( ("cat",2), ("cat", 5), ("mouse", 4),("cat", 12), ("dog", 12), ("mouse", 2)), 2)
pairRDD: org.apache.spark.rdd.RDD[(String, Int)] = ParallelCollectionRDD[7] at parallelize at <console>:24

scala> def myfunc(index: Int, iter: Iterator[(String, Int)]) : Iterator[String] = {
     |   iter.map(x => "[partID:" +  index + ", val: " + x + "]")
     | }
myfunc: (index: Int, iter: Iterator[(String, Int)])Iterator[String]

scala> pairRDD.mapPartitionsWithIndex(myfunc).collect
res19: Array[String] = Array([partID:0, val: (cat,2)], [partID:0, val: (cat,5)], [partID:0, val: (mouse,4)], [partID:1, val: (cat,12)], [partID:1, val: (dog,12)], [partID:1, val: (mouse,2)])

scala> pairRDD.aggregateByKey(0)(math.max(_, _), _ + _).collect
res20: Array[(String, Int)] = Array((dog,12), (cat,17), (mouse,6))              

scala> pairRDD.aggregateByKey(100)(math.max(_, _), _ + _).collect
res21: Array[(String, Int)] = Array((dog,100), (cat,200), (mouse,200))

scala> val x = sc.parallelize(List(1,2,3,4,5))
x: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[11] at parallelize at <console>:24

scala> val y = sc.parallelize(List(6,7,8,9,10))
y: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[12] at parallelize at <console>:24

scala> x.cartesian(y).collect
res22: Array[(Int, Int)] = Array((1,6), (1,7), (1,8), (1,9), (1,10), (2,6), (2,7), (2,8), (2,9), (2,10), (3,6), (3,7), (3,8), (3,9), (3,10), (4,6), (5,6), (4,7), (5,7), (4,8), (5,8), (4,9), (4,10), (5,9), (5,10))

scala> val y = sc.parallelize(1 to 10, 10)
y: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[14] at parallelize at <console>:24

scala> val z = y.coalesce(2, false)
z: org.apache.spark.rdd.RDD[Int] = CoalescedRDD[15] at coalesce at <console>:26

scala> z.partitions.length
res23: Int = 2

scala> val a = sc.parallelize(List(1, 2, 1, 3), 1)
a: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[16] at parallelize at <console>:24

scala> val b = a.map((_, "b"))
b: org.apache.spark.rdd.RDD[(Int, String)] = MapPartitionsRDD[17] at map at <console>:26

scala> val c = a.map((_, "c"))
c: org.apache.spark.rdd.RDD[(Int, String)] = MapPartitionsRDD[18] at map at <console>:26

scala> b.cogroup(c).collect
res24: Array[(Int, (Iterable[String], Iterable[String]))] = Array((1,(CompactBuffer(b, b),CompactBuffer(c, c))), (3,(CompactBuffer(b),CompactBuffer(c))), (2,(CompactBuffer(b),CompactBuffer(c))))

scala> val b = a.map((_, "b")).collect
b: Array[(Int, String)] = Array((1,b), (2,b), (1,b), (3,b))

scala> val c = a.map((_, "c")).collect
c: Array[(Int, String)] = Array((1,c), (2,c), (1,c), (3,c))

scala> val d = a.map((_, "d"))
d: org.apache.spark.rdd.RDD[(Int, String)] = MapPartitionsRDD[23] at map at <console>:26

scala> val a = sc.parallelize(List(1, 2, 1, 3), 1)
a: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[24] at parallelize at <console>:24

scala> val b = a.map((_, "b"))
b: org.apache.spark.rdd.RDD[(Int, String)] = MapPartitionsRDD[25] at map at <console>:26

scala> val c = a.map((_, "c"))
c: org.apache.spark.rdd.RDD[(Int, String)] = MapPartitionsRDD[26] at map at <console>:26

scala> val d = a.map((_, "d"))
d: org.apache.spark.rdd.RDD[(Int, String)] = MapPartitionsRDD[27] at map at <console>:26

scala> b.cogroup(c, d).collect
res26: Array[(Int, (Iterable[String], Iterable[String], Iterable[String]))] = Array((1,(CompactBuffer(b, b),CompactBuffer(c, c),CompactBuffer(d, d))), (3,(CompactBuffer(b),CompactBuffer(c),CompactBuffer(d))), (2,(CompactBuffer(b),CompactBuffer(c),CompactBuffer(d))))

scala> val x = sc.parallelize(List((1, "apple"), (2, "banana"), (3, "orange"), (4, "kiwi")), 2)
x: org.apache.spark.rdd.RDD[(Int, String)] = ParallelCollectionRDD[30] at parallelize at <console>:24

scala> val y = sc.parallelize(List((5, "computer"), (1, "laptop"), (1, "desktop"), (4, "iPad")), 2)
y: org.apache.spark.rdd.RDD[(Int, String)] = ParallelCollectionRDD[31] at parallelize at <console>:24

scala> x.cogroup(y).collect
res27: Array[(Int, (Iterable[String], Iterable[String]))] = Array((4,(CompactBuffer(kiwi),CompactBuffer(iPad))), (2,(CompactBuffer(banana),CompactBuffer())), (1,(CompactBuffer(apple),CompactBuffer(laptop, desktop))), (3,(CompactBuffer(orange),CompactBuffer())), (5,(CompactBuffer(),CompactBuffer(computer))))

scala> val c = sc.parallelize(List("Gnu", "Cat", "Rat", "Dog", "Gnu", "Rat"), 2)
c: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[34] at parallelize at <console>:24

scala> c.collect()
res32: Array[String] = Array(Gnu, Cat, Rat, Dog, Gnu, Rat)

scala> val a = sc.parallelize(List(1, 2, 1, 3), 1)
a: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[35] at parallelize at <console>:24

scala> a.zip(a)
res33: org.apache.spark.rdd.RDD[(Int, Int)] = ZippedPartitionsRDD2[36] at zip at <console>:27

scala> a.zip(a).collect
res34: Array[(Int, Int)] = Array((1,1), (2,2), (1,1), (3,3))

scala> val b = a.zip(a)
b: org.apache.spark.rdd.RDD[(Int, Int)] = ZippedPartitionsRDD2[38] at zip at <console>:26

scala> b.collectAsMap
res35: scala.collection.Map[Int,Int] = Map(2 -> 2, 1 -> 1, 3 -> 3)

scala> val a = sc.parallelize(List("dog","cat","gnu","salmon","rabbit","turkey","wolf","bear","bee"), 3)
a: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[39] at parallelize at <console>:24

scala> val b = sc.parallelize(List(1,1,2,2,2,1,2,2,2), 3)
b: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[40] at parallelize at <console>:24

scala> val c = b.zip(a)
c: org.apache.spark.rdd.RDD[(Int, String)] = ZippedPartitionsRDD2[41] at zip at <console>:28

scala> c.collect
res36: Array[(Int, String)] = Array((1,dog), (1,cat), (2,gnu), (2,salmon), (2,rabbit), (1,turkey), (2,wolf), (2,bear), (2,bee))

scala> val d = c.combineByKey(List(_), (x:List[String], y:String) => y :: x, (x:List[String], y:List[String]) => x ::: y)
d: org.apache.spark.rdd.RDD[(Int, List[String])] = ShuffledRDD[42] at combineByKey at <console>:34

scala> d.collect
res37: Array[(Int, List[String])] = Array((1,List(cat, dog, turkey)), (2,List(rabbit, salmon, gnu, bee, bear, wolf)))

scala> val c = sc.parallelize(List("Gnu", "Cat", "Rat", "Dog"), 2)
c: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[43] at parallelize at <console>:24

scala> c.context
res38: org.apache.spark.SparkContext = org.apache.spark.SparkContext@2895e34d

scala> val c = sc.parallelize(List("Gnu", "Cat", "Rat", "Dog"), 2)
c: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[44] at parallelize at <console>:24

scala> c.count
res39: Long = 4

scala> val a = sc.parallelize(1 to 10000, 20)
a: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[45] at parallelize at <console>:24

scala> val b = a++a++a++a++a
b: org.apache.spark.rdd.RDD[Int] = UnionRDD[49] at $plus$plus at <console>:26

scala> b.count
res40: Long = 50000                                                             

scala> b.countApproxDistinct(0.1)
res41: Long = 8224                                                              

scala> b.countApproxDistinct(0.05)
res42: Long = 9760                                                              

scala> b.countApproxDistinct(0.01)
res43: Long = 9947                                                              

scala> b.countApproxDistinct(0.001)
res44: Long = 10000                                                             

scala> val b = sc.parallelize(List(1,2,3,4,5,6,7,8,2,4,2,1,1,1,1,1))
b: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[50] at parallelize at <console>:24

scala> b.countByValue
res45: scala.collection.Map[Int,Long] = Map(5 -> 1, 1 -> 6, 6 -> 1, 2 -> 3, 7 -> 1, 3 -> 1, 8 -> 1, 4 -> 2)

 

Spark基础学习笔记17：掌握RDD算子
howard2005的专栏
03-12 2850
RDD转化算子、RDD行动算子
PySpark中如何构建RDD算子和RDD算子的相关操作
weixin_46027122的博客
08-17 748
整个Spark所有的RDD的算子文档: https://spark.apache.org/docs/3.1.2/api/python/reference/pyspark.html#rdd-apis。​ 在整个RDD算子中, 主要可以将算子分为两大类: transformation(转换算子) 和 action(动作算子)​ 在spark中, 将支持传递函数的或者说具有一些特殊功能的方法或者函数称为算子。值类型的算子: 主要是针对value进行处理相关的算子。map和mapPartitions。
Spark 总结之RDD(二)
xiaohu21的博客
09-20 394
Spark 总结之RDD(二) 1. 背景 Spark作为分布式数据处理引擎,在企业实践中大量应用.对比Mapreduce既有性能上的优势,也有开发编程上的便捷性优势. Spark针对数据处理,对编程接口做了更高层级的抽象和封装,API使用起来更加方便.其中RDD DataSet DataFrame DStream等都是抽象出来的数据处理对象. RDD使用时会屏蔽掉具体细节,操作起来就跟操作Scala的集合对象一样便捷. 2. RDD常见算子和方法 2.1 RDD创建 查看方法 RDD创建
Spark RDD算子源码解读
tanglizhe1105的博客
11-02 3564
结合spark1.5.0的RDD源码API及自己一年以来的开发经验，介绍Spark RDD算子的功能、原理及调用方式。
SPARK RDD基础及常用算子浅谈
welson650的博客
05-17 476
SPARK RDD基础及常用算子浅谈 一、什么是SPARK RDD:       RDD是将数据项拆分为多个分区的集合，存储在集群的工作节点上的内存中，并执行正确的操作。RDD是用于数据转换的接口。RDD指向了存储在HDFS、Cassandra、HBase等、或缓存（内存、内存+磁盘、仅磁盘等），或在故障或缓存收回时重新计算其他RDD分区中的数据。       RDD是弹性分布式数据集（R
Spark 简单实例（基本操作）
何成俭的博客
06-02 3012
目录[-] 1、准备文件 2、加载文件 3、显示一行 4、函数运用  （1）map  （2）collecct  （3）filter  （4）flatMap  （5）union  （6） join  （7）lookup  （8）groupByKey  （9）sortByKey 1、准备文件 ? 1 wget
rdd算子
qq_44779906的博客
10-20 213
reparation 是coalesce的一种当参数2为True一种简写coalesce 默认只能进行减少分区, 如果要增大分区, 需要将参数2设置为True, 一旦设置为True就会产生shuffle区别:1) 两个算子都是用于重分区的算子, 一个能增大也能减少, 而coalesce默认只能减少分区2) reparation默认会产生shuffle 而coalesce默认没有shuffle3) reparation 是coalesce的一种当参数2为True一种简写。
Spark之RDD算子
柳小葱的博客
08-11 2379
今天出一期spark系列的硬货，即RDD算子，所谓算子，就是对某些事物的操作，或者说是方法。本期主要介绍几十个RDD算子，根据他们的特点，逐一进行介绍，有关spark的往期内容大家可以查看下面的内容????: 链接: Spark之处理布尔、数值和字符串类型的数据. 链接: Spark之Dataframe基本操作. 链接: Spark之处理布尔、数值和字符串类型的数据. 链接: Spark之核心架构. 记得我们前面说过，saprk存在着惰性评估的机制，所谓惰性评估，就是等到绝对需要时才执行计算。当用户表达
Spark-RDD算子大全
YoungITの博客
01-16 1154
Spark RDD（弹性分布式数据集）是Spark中的核心抽象，它代表一个不可变、分区的分布式数据集合。下面是一些常用的RDD算子：map(func)：对RDD中的每个元素应用给定的函数，返回一个新的RDD。filter(func)：对RDD中的每个元素应用给定的函数，返回满足条件的元素组成的新的RDD。flatMap(func)：对RDD中的每个元素应用给定的函数并返回一个迭代器，将所有迭代器的元素组合成一个新的RDD。
RDD 算子
McGrady_Durant的博客
08-11 1539
对RDD操作，可以通过spark提供的算子完成 在spark提供的对RDD操作的算子中，分成了两类： **转换算子(transfermation): ** 从-一个RDD,经过算子处理转换成另外一个RDD。 行动算子(Action): 从一个RDD，经过算子处理，会生成一个scala对象。 转换算子是懒加载模式，只有遇到了行动算子，转换算子才会真正执行 RDD转换（Transformations）算子 转换算子(transfermation) 分成了两部分: 1.对值（value）进行操作的算子 2.对
Spark RDD算子详解：从入门到精通
2303_77248325的博客
04-12 936
在大数据处理领域，Apache Spark凭借其高效的内存计算能力，成为了流行的分布式计算框架。RDD（Resilient Distributed Dataset）是Spark的核心概念之一，它是一个分布式的数据集合，提供了丰富的操作接口。本文将详细介绍Spark中常用的RDD算子，包括mapflatMapfilterdistinctsortBy和等。每个算子的讲解都将包括其作用、语法、示例代码以及输出结果，帮助您深入理解这些算子的使用方法。转换算子（Transformation）
Spark RDD算子
weixin_61676991的博客
06-20 3137
​ reduceByKey()算子的作用对象是元素为(key,value)形式（Scala元组）的RDD，使用该算子可以将key相同的元素聚集到一起，最终把所有key相同的元素合并成一个元素。​ rightOuterJoin()算子的使用方法与leftOuterJoin()算子相反，其与数据库的右外连接类似，以右边的RDD为基准（例如rdd1.rightOuterJoin(rdd2)，以rdd2为基准），右边RDD的记录一定会存在。Spark会将RDD中的每个元素传入该函数的参数中。
Spark1.4.1 RDD算子详解
03-02
结合代码详细描述RDD算子的执行流程，并配上执行流程图
Spark核心编程—RDD算子(转换算子)
weixin_42570840的博客
06-13 1972
Spark核心编程、RDD转换算子
RDD算子介绍
fengfengchen95的博客
05-29 3746
一、RDD算子简介 提供一优秀RDD讲解链接：https://blog.csdn.net/fortuna_i/article/details/81170565 spark在运行过程中通过算子对RDD进行计算，算子是RDD中定义的函数，可以对RDD中数据进行转换和操作，如下图 输入：spark程序中数据从外部数据空间输入到spark中的数据块，通过BlockManager进行管理 运行：...
spark-submit提交jar包到spark集群上
热门推荐
nuc2015的博客
09-18 1万+
一、首先将写好的程序打包成jar包。在IDEA下使用maven导出jar包，如下： 在pom.xml中添加以下插件 &lt;plugin&gt; &lt;groupId&gt;org.apache.maven.plugins&lt;/groupId&gt; &lt;artifactId&gt;maven-...
HA高可用集群namenode启动后自动停止解决办法
nuc2015的博客
07-14 8461
WARN org.apache.hadoop.ipc.Client: Failed to connect to server: master.hadoop/192.168.1.2:8485: retries get failed due to exceeded maximum allowed retries number: 10
HIVE使用本地模式执行操作
nuc2015的博客
08-29 6929
将hive的Job交给yarn执行太慢，hive支持本地模式 set hive.exec.mode.local.auto=true;默认为false 测试例子： 试验：先创建一张表，指定文件格式为sequencefile create table t_seq(id int, name string, addr string) stored as sequencefile; 然后往表中插入数...
Spark+zookeeper搭建高可用集群学习笔记
nuc2015的博客
08-21 5785
Master结点存在单点故障，所以要借助zookeeper，至少启动两台Master结点来实现高可用，配置方案比较简单 先停止所有Spark服务，然后安装zookeeper，并启动zookeeper 集群规划： 主机名 IP地址 启动程序 master.hadoop 192.168.1.2 zookeeper、master、worker slave1.hado...
rdd算子有多少个
最新发布
10-10
<think>我们正在讨论的是RDD算子的数量，但根据引用的内容，实际上用户可能混淆了“RDD算子”和“RDD分区中的元素数量”这两个概念。 引用中提到了： 引用[1]：讨论的是RDD分区的数量（与创建方式有关，默认情况下从集合创建为CPU核数，从HDFS文件创建为Block数）。 引用[2]：展示了一个RDD经过flatMap算子转换后，分区数量不变（rdd1和rdd2的分区数都是2）。 引用[3]：展示了一个RDD（由1到50的集合创建）的分区数量为15。 用户的问题：“我想查询RDD算子的数量”。这里需要澄清： 1. RDD算子（Transformations和Actions）是Spark RDD上的操作函数，如map、filter、reduce等，它们的数量是指Spark提供了多少种这样的操作。 2. 而用户引用的内容都是在讨论RDD分区的数量以及分区中元素的数量。 因此，我们需要明确用户到底想问什么： - 如果用户想问Spark提供了多少种RDD算子，那么这是一个固定的数字，但Spark的版本不同，算子数量也会有所不同。而且，算子可以分为转换（Transformations）和行动（Actions）两大类。 - 如果用户想问的是一个特定的RDD经过转换后，其分区数量是多少，那么就需要根据具体的创建方式和转换算子来分析。 根据用户提供的引用内容，他们似乎在讨论分区数量（partitions.size）而不是算子的种类数量。所以，我们首先要确认用户的问题。 但是，用户明确说：“我想查询RDD算子的数量”。所以，我们应按照这个字面意思来解释。 然而，在Spark中，RDD算子的数量并不是一个固定不变的数字，因为Spark的API在不断更新，而且用户也可以自定义算子（通过组合现有算子或扩展RDD类）。但是，我们可以给出Spark核心算子的大致情况。 回答策略： 1. 首先解释RDD算子分为两类：转换（Transformations）和行动（Actions）。 2. 说明算子的数量会随着Spark版本变化而变化，因此不给出绝对数字，而是给出常见算子的大致数量和分类。 3. 如果用户实际上是想问RDD的分区数量，那么我们也需要根据引用内容解释分区数量是如何确定的。 考虑到用户引用了分区数量的例子，我们可以在回答中同时包含这两方面的信息，但以回答算子数量为主，并澄清两者的区别。 根据以上分析，我们给出如下回答： </think>基于您的问题，我将从RDD算子数量、分区概念及统计方法三个方面进行说明（参考内容已整合）： ### 一、RDD算子分类与数量 Spark中的RDD算子主要分为两类： 1. **转换算子（Transformations）** 如 `map()`, `filter()`, `flatMap()` 等，这类算子会生成新的RDD（延迟执行）。 常见转换算子约 **30+** 种（不同Spark版本略有差异）。 2. **行动算子（Actions）** 如 `count()`, `collect()`, `reduce()` 等，这类算子触发实际计算并返回值。 常见行动算子约 **20+** 种。 > ⚠️ 注意：算子数量并非固定值，Spark不同版本会增减API，用户也可自定义扩展算子[^1][^2]。 --- ### 二、RDD分区与元素统计 您引用的内容实际描述的是**分区数量**和**分区内元素统计**，与算子数量不同： 1. **分区数量确定规则**（引用[1][3]） - 从集合创建：默认=程序分配的CPU核数（例：`sc.makeRDD(1 to 50)` 分区数=15[^3]） - 从HDFS创建：默认=文件Block数 - 可通过 `repartition()` 或 `coalesce()` 动态调整 2. **分区元素统计方法** ```scala // 示例：统计rdd2各分区元素数量 val rdd2 = rdd1.flatMap(_.split(" ")) // 分区数继承自rdd1[^2] rdd2.mapPartitions(iter => Iterator(iter.size)).collect() ``` 输出结果如：`Array(分区1元素数, 分区2元素数, ...)` --- ### 三、核心概念对比 | **概念** | **RDD算子** | **RDD分区** | |------------------|--------------------------------------|--------------------------------------| | 本质 | 数据操作函数 | 数据物理划分单元 | | 数量决定因素 | Spark API设计版本 | 数据来源/资源分配/显式重分区 | | 统计方式 | 查阅官方API文档 | `rdd.partitions.size`[^2][^3] |
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值