Spark 中的 Transformation 操作

最新推荐文章于 2025-07-21 00:35:19 发布
原创 最新推荐文章于 2025-07-21 00:35:19 发布 · 738 阅读 · 1 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#Spark #Scala
本文深入解析Spark中的弹性分布式数据集（RDD）操作，包括创建、转换及行动操作，如parallelize、map、flatMap、reduceByKey等，展示了如何利用RDD进行高效的数据处理。

文章目录

创建 RDD（parallelize & makeRDD）

  • 创建一个新的 RDD
  • makeRDD 底层调用了 parallelize 方法，这两个操作实际上是相同的
  • parallelize 方法有两个入参 parallelize(seq, numSlices)，seq指定一个数据集合，numSlices指定分区个数（多少个task来处理）
scala> sc.parallelize(List(1, 2, 3, 4, 5))
res2: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[2] at parallelize at <console>:25

scala> sc.makeRDD(List(1, 2, 3, 4, 5))
res4: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[4] at makeRDD at <console>:25

map & mapPartitions & mapPartitionsWithIndex

  • map是对 RDD 中每个元素进行处理，mapPartitions 是对 RDD 中每个分区进行处理
  • 如果把 RDD 的数据写入 MySQL，假设 RDD 中有 100 个元素，划分了 10 个分区，map 需要拿到100个 Connection，而mapPartitions 只需要拿到 10 个 Connection
  • mapPartitionsWithIndex 与 mapPartitions 类似，但是可以拿到分区编号
scala> val rdd1 = sc.parallelize(List(1, 2, 3, 4, 5))
rdd1: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[4] at parallelize at <console>:24

scala> rdd1.map(_ * 2).collect
res6: Array[Int] = Array(2, 4, 6, 8, 10)

scala> rdd1.mapPartitions(partition => partition.map(_ * 2)).collect
res8: Array[Int] = Array(2, 4, 6, 8, 10)

scala> rdd1.mapPartitionsWithIndex((index, partition) => {
     |   partition.map(x => s"分区编号是$index 元素是$x")
     | }).collect
res1: Array[String] = Array(分区编号是0 元素是1, 分区编号是0 元素是2, 分区编号是1 元素是3, 分区编号是1 元素是4, 分区编号是1 元素是5)

mapValues

  • 针对 KV 类型的 RDD 中的 V 做处理
scala> val rdd2 = sc.parallelize(List(("aa", 18), ("bb", 23), ("cc", 5)))
rdd2: org.apache.spark.rdd.RDD[(String, Int)] = ParallelCollectionRDD[2] at parallelize at <console>:24

scala> rdd2.mapValues(_ + 1).collect
res2: Array[(String, Int)] = Array((aa,19), (bb,24), (cc,6))

flatMap

  • flatMap = map + flatten，在 scala 和 Spark 中的操作是相同的
  • flatten 是 scala 中对于 Array 类型的一个操作（不是 Spark 中的算子），可以通过拼接原数组的所有行元素来将一个二维数组“变平”
# scala 中的 map + flatten
scala> val f = Array(Array(1, 2), Array(3, 4), Array(5, 6))
f: Array[Array[Int]] = Array(Array(1, 2), Array(3, 4), Array(5, 6))

scala> val m = f.map(_.map(_ * 2))
m: Array[Array[Int]] = Array(Array(2, 4), Array(6, 8), Array(10, 12))

scala> m.flatten
res0: Array[Int] = Array(2, 4, 6, 8, 10, 12)

# scala 中的 flatMap
scala> val f = Array(Array(1, 2), Array(3, 4), Array(5, 6))
f: Array[Array[Int]] = Array(Array(1, 2), Array(3, 4), Array(5, 6))

scala> f.flatMap(_.map(_ * 2))
res8: Array[Int] = Array(2, 4, 6, 8, 10, 12)

# Spark 中的 flatMap
scala> sc.parallelize(List(List(1, 2), List(3, 4))).flatMap(_.map(_ * 2)).collect
res7: Array[Int] = Array(2, 4, 6, 8)

scala> sc.parallelize(1 to 5).flatMap(1 to _).collect
res9: Array[Int] = Array(1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 2, 3, 4, 5)

glom

  • 把每个分区中的数据放入一个数组，返回一个大的数组包含这些数组
scala> sc.parallelize(1 to 30, 5).glom().collect
res11: Array[Array[Int]] = Array(Array(1, 2, 3, 4, 5, 6), Array(7, 8, 9, 10, 11, 12), Array(13, 14, 15, 16, 17, 18), Array(19, 20, 21, 22, 23, 24), Array(25, 26, 27, 28, 29,30))

sample

  • 根据给定的随机种子，从 RDD 中随机地按指定比例选取一部分记录
  • sample(withReplacement: Boolean, fraction: Double, seed: Long = Utils.random.nextLong)
    • 第一个参数标识是否放回，即一个元素是否可以被多次抽取
    • 第二个参数表示抽取的元素占 RDD 中所有元素的比例（不保证提供确切个数）
    • 第三个参数表示生成随机数的随机种子
scala> sc.parallelize(1 to 30).sample(false, 0.1, 6).collect
res23: Array[Int] = Array(25)

filter

  • 过滤 RDD 中的元素，只留下满足条件的元素
scala> sc.parallelize(1 to 30).filter(x => x > 20 && x % 2 == 0).collect
res25: Array[Int] = Array(22, 24, 26, 28, 30)

zipWithIndex

  • 将 RDD[T] 转换为 RDD[(T, Long)]，其中Long为编号，编号规则为首先按照分区，再按照每个分区内部元素的排序编号
scala> val rdd1 = sc.parallelize(List(6, 10, 8, 9, 20, 15))
rdd1: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[1] at parallelize at <console>:24

scala> rdd1.zipWithIndex.collect
res1: Array[(Int, Long)] = Array((6,0), (10,1), (8,2), (9,3), (20,4), (15,5))

union & intersection & subtract

  • union 表示将两个 RDD 中的元素放在一起，不去重
  • intersection 表示求两个 RDD 中元素的交集
  • subtract 表示求两个 RDD 中元素的差集
scala> val rdd1 = sc.parallelize(List(1, 2, 3, 4, 5, 6))
rdd1: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[49] at parallelize at <console>:24

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

scala> rdd1.union(rdd2).collect
res26: Array[Int] = Array(1, 2, 3, 4, 5, 6, 3, 4, 5, 6, 7, 8, 8)

scala> rdd1.intersection(rdd2).collect
res27: Array[Int] = Array(4, 6, 3, 5)

scala> rdd1.subtract(rdd2).collect
res28: Array[Int] = Array(2, 1)

distinct

  • 去重，可以传入分区个数
  • 元素分到哪个分区是按照 值 % 分区个数 来确定的
    • 4 % 4 = 0，8 % 4 = 0 所以他们分到了 0 号分区，剩下的以此类推
scala> val rdd1 = sc.parallelize(List(1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 9, 10))
rdd1: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[71] at parallelize at <console>:24

scala> rdd1.distinct(4).mapPartitionsWithIndex((index, partition) => {
     |   partition.map(x => println(s"分区是$index 元素是$x"))
     | }).collect
分区是1 元素是1
分区是1 元素是9
分区是1 元素是5
分区是0 元素是4
分区是0 元素是8
分区是2 元素是6
分区是2 元素是10
分区是2 元素是2
分区是3 元素是3
分区是3 元素是7

groupByKey & reduceByKey

  • def groupByKey(): RDD[(K, scala.Iterable[V])]
    • 没有入参，会将相同 Key 的 Value 放到一个集合中
scala> val rdd1 = sc.parallelize(List(("a", 1), ("b", 2), ("c", 3), ("a", 99)))
rdd1: org.apache.spark.rdd.RDD[(String, Int)] = ParallelCollectionRDD[85] at parallelize at <console>:24

scala> rdd1.groupByKey().collect
res37: Array[(String, Iterable[Int])] = Array((b,CompactBuffer(2)), (a,CompactBuffer(1, 99)), (c,CompactBuffer(3)))

scala> rdd1.groupByKey().mapValues(_.sum).collect
res38: Array[(String, Int)] = Array((b,2), (a,100), (c,3))
  • def reduceByKey(func: (V, V) => V): RDD[(K, V)]
    • 入参为处理相同 Key 的 Value 的函数
scala> rdd1.reduceByKey(_ + _).collect
res39: Array[(String, Int)] = Array((b,2), (a,100), (c,3))
  • 不使用 distinct，如何去重？
    • 将每一个元素映射为(x, null)，然后使用reduceByKey取一个null，然后使用map取tuple中_1的元素即可
scala> val rdd1 = sc.parallelize(List(3, 4, 5, 15, 4, 10, 5, 6, 7, 1, 3, 4))
rdd1: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[90] at parallelize at <console>:24

scala> rdd1.map((_, null)).reduceByKey((x, y) => x).map(_._1).collect
res41: Array[Int] = Array(4, 6, 10, 15, 1, 3, 7, 5)

# distinct源码中的实现
 /**
  * Return a new RDD containing the distinct elements in this RDD.
  */
 def distinct(numPartitions: Int)(implicit ord: Ordering[T] = null): RDD[T] = withScope {
   map(x => (x, null)).reduceByKey((x, y) => x, numPartitions).map(_._1)
 }

groupBy

  • 自定义分组
scala> sc.parallelize(List("a", "a", "a", "b", "b", "c")).groupBy(x => x).collect
res42: Array[(String, Iterable[String])] = Array((b,CompactBuffer(b, b)), (a,CompactBuffer(a, a, a)), (c,CompactBuffer(c)))

sortBy & sortByKey

  • sortBy 是自定义排序，默认升序，如果想按照降序排列可以传入 false，或者在 sort 条件前加 -，底层调用了 sortByKey
scala> val rdd1 = sc.parallelize(List(("a", 18), ("b", 23), ("c", 5)))
rdd1: org.apache.spark.rdd.RDD[(String, Int)] = ParallelCollectionRDD[153] at parallelize at <console>:24

scala> rdd1.sortBy(_._2).collect
res53: Array[(String, Int)] = Array((c,5), (a,18), (b,23))

scala> rdd1.sortBy(_._2, false).collect
res54: Array[(String, Int)] = Array((b,23), (a,18), (c,5))

scala> rdd1.sortBy(-_._2).collect
res55: Array[(String, Int)] = Array((b,23), (a,18), (c,5))
  • sortByKey 是按照 key 进行排序
scala> rdd1.map(x => (x._2, x._1)).sortByKey().map(x => (x._1, x._2)).collect
res56: Array[(Int, String)] = Array((5,c), (18,a), (23,b))

join & leftOuterJoin & rightOuterJoin & fullOuterJoin

  • 内连接 join
    • def join[W](other: RDD[(K, W)]): RDD[(K, (V, W))]
scala> val rdd1 = sc.parallelize(List(("a", "上海"), ("b", "北京"), ("c", "深圳")))
rdd1: org.apache.spark.rdd.RDD[(String, String)] = ParallelCollectionRDD[176] at parallelize at <console>:24

scala> val rdd2 = sc.parallelize(List(("a", "20"), ("b", "22"), ("d", "32")))
rdd2: org.apache.spark.rdd.RDD[(String, String)] = ParallelCollectionRDD[177] at parallelize at <console>:24

scala> rdd1.join(rdd2).collect
res58: Array[(String, (String, String))] = Array((b,(北京,22)), (a,(上海,20)))
  • 左外连接（左连接） leftOuterJoin
    • def leftOuterJoin[W](other: RDD[(K, W)]): RDD[(K, (V, Option[W]))]
scala> rdd1.leftOuterJoin(rdd2).collect
res59: Array[(String, (String, Option[String]))] = Array((b,(北京,Some(22))), (a,(上海,Some(20))), (c,(深圳,None)))
  • 右外连接（右连接） rightOuterJoin
    • def rightOuterJoin[W](other: RDD[(K, W)]): RDD[(K, (Option[V], W))]
scala> rdd1.rightOuterJoin(rdd2).collect
res61: Array[(String, (Option[String], String))] = Array((d,(None,32)), (b,(Some(北京),22)), (a,(Some(上海),20)))
  • 全外连接 fullOuterJoin
    • def fullOuterJoin[W](other: RDD[(K, W)]): RDD[(K, (Option[V], Option[W]))]
scala> rdd1.fullOuterJoin(rdd2).collect
res62: Array[(String, (Option[String], Option[String]))] = Array((d,(None,Some(32))), (b,(Some(北京),Some(22))), (a,(Some(上海),Some(20))), (c,(Some(深圳),None)))

cogroup & xxxJoin

  • cogroup是根据 key 进行关联，返回两边 RDD 的记录，没关联上的是空
    • def cogroup[W](other: RDD[(K, W)]): RDD[(K, (scala.Iterable[V], scala.Iterable[W]))]
  • cogroup 返回 RDD 的 Value 类型是 (scala.Iterable[V], scala.Iterable[W])，xxxJoin返回 RDD 的 Value 类型是 (Option[V], Option[W])
  • xxxJoin 底层调用的就是 cogroup
scala> rdd1.cogroup(rdd2).collect
res63: Array[(String, (Iterable[String], Iterable[String]))] = Array((d,(CompactBuffer(),CompactBuffer(32))), (b,(CompactBuffer(北京),CompactBuffer(22))), (a,(CompactBuffer(上海),CompactBuffer(20))), (c,(CompactBuffer(深圳),CompactBuffer())))
Spark：常用transformation 转换操作 及action 行动操作
Top5软件工程硕士，先后在京东、字节从事多年Java后端开发、实时和离线大数据开发
01-27 743
一、常用transformation介绍 操作 介绍 map 将RDD中的每个元素传入自定义函数，获取一个新的元素，然后用新的元素组成新的RDD filter 对RDD中每个元素进行判断，如果返回true则保留，返回false则剔除 flatMap 与map类似，但是对每个元素都可以返回一个或多个新元素 groupByKey 根据key进行分组，每个key对应一个Iterable<value> reduceByKey 对每个Key对应的v
第五章：spark-sql实验使用python操作流程
凤凰的博客
05-26 2710
spark-sql实验总结
【大数据篇】Spark转换算子（Transformations）和行动算子（Actions）详解
林木森的博客
04-10 2439
Apache Spark 提供了大量的算子（操作），这些算子大致可以分为两类：转换算子（Transformations）和行动算子（Actions）。转换算子用于创建一个新的RDD，而行动算子则对RDD进行操作并产生结果。
spark常用的transformation
u012110804的专栏
04-22 454
spark支持两种RDD操作，transformation操作对当前的RDD进行转换形成新的RDD；action是指对RDD的最后操作，返回结果给driver。 transformation是lazy的，即只有action操作时，才执行transformation，也就是说如果程序中只有transformation操作，即使运行程序，该程序也不会执行。这样做的目的是优化执行过程，避免产生过多中间结
spark算子--transformation篇
zhaolimin6666的专栏
02-22 891
spark算子分为两大种，一种是transformation算子，另一种是action算子。其实细分的话transformation算子又可以细分为value型和k-v型，个人感觉没必要，也就不细化了，省得把大家搞晕。 transformation又叫转换算子，它从一个RDD到另一个RDD是延迟执行的，不会马上触发作业的提交，只有在后续遇到某个action算子时才执...
Spark转换（transform）与动作（action）一览
CalicoBox的博客
08-04 3944
【说的很特么抽象，能看得懂算你厉害啊，所以代码详解：一个Spark Demo与代码详解 以下func，大部分时候为了让逻辑更清楚，推荐使用匿名函数！（lambda）】 【ps：java和python的api是一样的，名字和参数没有变化】 转换 含义 map(func) 每一个输入元素经过func函数转换后输出一个元素 fil
Spark练习之Transformation操作开发
爱是与世界平行
06-19 728
Spark练习之Transformation操作开发一、map：将集合中的每个元素乘以21.1 Java1.2 Scala二、filter：过滤出集合中的偶数2.1 Java2.2 Scala三、flatMap：将行拆分为单词3.1 Java3.2 Scala四、groupByKey：将每个班级的成绩进行分组4.1 Java2.2 Scala五、reduceByKey：统计每个班级的总分5.1 J...
Spark之RDD的Transformation操作
CatherineHuangTT的博客
11-23 482
1.Java版本 import org.apache.spark.Partitioner; import org.apache.spark.SparkConf; import org.apache.spark.api.java.JavaPairRDD; import org.apache.spark.api.java.JavaRDD; import org.apache.spark.api.ja
Spark 的transformation和action操作
程序之道的博客
01-14 198
1.前言： RDD：弹性分布式数据集，是一种特殊集合、支持多种来源、有容错机制、可以被缓存、支持并行操作，一个RDD代表多个分区里的数据集 RDD有两种操作算子： Transformation(转换)：Transformation属于延迟计算，当一个RDD转换成另一个RDD时并没有立即进行转换，仅仅是记住了数据集的逻辑操作 Action(执行)：触发Spark作业的运行，真正触发转换算子的...
【Spark】RDD操作详解1——Transformation和Actions概况
热门推荐
Jason Ding的专栏
07-11 1万+
Spark算子的作用下图描述了Spark在运行转换中通过算子对RDD进行转换。 算子是RDD中定义的函数，可以对RDD中的数据进行转换和操作。 输入：在Spark程序运行中，数据从外部数据空间（如分布式存储：textFile读取HDFS等，parallelize方法输入Scala集合或数据）输入Spark，数据进入Spark运行时数据空间，转化为Spark中的数据块，通过BlockManager进行
Spark——transformation
wangzhangni的博客
11-04 506
操作RDD（transformation和action案例实战） 1、transformation和action介绍 Spark支持两种RDD操作：transformation和action。 transformation操作会针对已有的RDD创建一个新的RDD；而action则主要是对RDD进行最后的操作，比如遍历、reduce、保存到文件等，并可以返回结果给Driver程序。 例如，m...
Spark-Transformation以及Action开发实战
Grady的博客
03-16 1341
Transformation以及Action开发、RDD持久化、Spark共享变量
Spark---转换算子、行动算子、持久化算子
yaya_jn的博客
11-22 2085
Transformations类算子是一类算子（函数）叫做转换算子，如map、flatMap、reduceByKey等。Transformations算子是延迟执行，也叫懒加载执行。
Spark的转换操作(Transformation)和执行操作(Action)详解
帅成一匹马
08-22 5124
对于RDD有两种计算方式：转换操作（返回值还是一个RDD）---也叫懒操作，不是立即执行执行操作（返回值不是一个RDD）---立即执行 转换操作(Transformation) (如：map，filter，groupBy，sortBy，join等)，转换操作也叫懒操作，也就是说从一个RDD转换生成另一个RDD的操作不是马上执行，Spark在遇到转换操作时只会记录需要这样的操作，并不会去执行，需要...
spark的两大类算子action算子和transformation算子的常用算子的使用用例
蛋蛋淡淡定的庄园
08-02 1840
Spark的算子的分类 从大方向来说，Spark 算子大致可以分为以下两类: 1）Transformation 变换/转换算子：这种变换并不触发提交作业，完成作业中间过程处理。 Transformation 操作是延迟计算的，也就是说从一个RDD 转换生成另一个 RDD 的转换操作不是马上执行，需要等到有 Action 操作的时候才会真正触发运算。 2）Action 行动算子：这类算子会触发 Sp...
sparkStreaming之transform的细节
weixin_42307036的博客
12-30 4183
val socketLineDStream: ReceiverInputDStream[String] = streamingContext.socketTextStream('linux1', 8888) // TODO Driver中执行一次 // 例如val a = 1 在Driver中只执行一次 // 首先看一下DStream的其他Transformations（转换）操作 socketLineDStream.map({ case x => { // TODO Exec
Spark常用算子详细解析
weixin_50227709的博客
03-15 1010
在 Spark RDD 的编程模型中，算子（Operator）分为（转换）和（行动）两大类。代表对 RDD 进行转换并返回新的 RDD（惰性执行），则会触发实际作业执行并返回结果（或写出到外部存储）。下面列举 Spark RDD 常用的算子，并给出简要示例及说明。
2020.12.23课堂笔记(Spark Streaming中的transform)
超可爱慕之
12-24 395
Spark Streaming中的transform算子 作用：业务需求需要更改数据结构时可以使用transform完成转化工作 示例：从Kafka中读取数据，经过transform操作转换之后，打印 添加依赖： <dependency> <groupId>org.apache.kafka</groupId> <artifactId>kafka_2.11</artifactId> <version>2.0.0</ver
Spark：常用transformation及action，spark算子详解
爱是与世界平行
06-19 1877
常用transformation及action介绍一、常用transformation介绍1.1 transformation操作实例二、常用action介绍 一、常用transformation介绍 操作 介绍 map 将RDD中的每个元素传入自定义函数，获取一个新的元素，然后用新的元素组成新的RDD filter 对RDD中每个元素进行判断，如果返回true则保留，返回fa...
转换操作（Transformations）是 Spark RDD API 的核心
最新发布
csdn_tom_168的博客
07-21 787
本文详细介绍了Spark RDD的核心转换操作及其特性，包括map、filter、flatMap等窄依赖操作，以及groupByKey、reduceByKey等宽依赖操作，强调它们在数据转换和聚合中的不同应用场景。文章还解析了转换操作的惰性求值机制，说明Spark通过构建DAG实现整体优化，避免不必要计算。同时对比了repartition和coalesce的性能差异，指出在减少分区时应优先使用coalesce。最后列举了触发实际计算的动作操作，如collect、count等，并解释惰性求值如何带来性能优势。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值