【Spark】算子

最新推荐文章于 2024-01-23 17:32:35 发布
最新推荐文章于 2024-01-23 17:32:35 发布
阅读量506 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： Spark BigData 文章标签： Spark RDD 算子
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xin93/article/details/80546765
本文介绍了Apache Spark中RDD的各种操作，包括转换操作如mapWith、flatMapWith等，以及行动操作如countByKey、filterByRange等。详细解释了这些操作的功能及使用场景，并提供了具体的代码示例。

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

1. mapWith
mapWith(i => i*10)((a,b) => b+2)
(拿到分区号)(a是每次取到的RDD中的元素，b接收i*10的结果)
2. flatMapWith
类似mapWith，区别在于flatMapWith返回的是一个序列

3. mapPartitions
每次取到的是分区号
val rdd1 = sc.parallelize(Array(1,2,3,4,5,6,7),3)
对分区每个元素乘10
rdd1.mapPartitions(_.map(_ * 10))

4. mapPartitionsWithIndex
对RDD中的每个分区进行操作，带有分区号
val rdd1 = sc.parallelize(List(1,2,3,4,5,6,7,8,9),2)
创建一个函数
(index分区号，iter分区中的每个元素)
def func1(index:Int,iter:Iterator[Int]):Iterator[String] ={
ter.toList.map(x=>"[PartID:" + index +",value="+x+"]").iterator
}
rdd1.mapPartitionsWithIndex(func1).collect
结果：
Array(
[PartID:0,value=1], [PartID:0,value=2], [PartID:0,value=3], [PartID:0,value=4],
[PartID:1,value=5], [PartID:1,value=6], [PartID:1,value=7], [PartID:1,value=8], [PartID:1,value=9])

5. aggregate：聚合操作
先对局部进行操作，再对全局进行操作
val rdd1 = sc.parallelize(List(1,2,3,4,5),2)
（初始值）（局部操作，全局操作）
rdd1.aggregate(0)(math.max(_,_),_+_)

6. aggregateByKey
类似aggregate，也是先对局部，再对全局
区别：aggregateByKey操作<key,value>
val pairRDD = sc.parallelize(List( ("cat",2), ("cat", 5), ("mouse", 4),("cat", 12), ("dog", 12), ("mouse", 2)), 2)
把每个笼子中，每种动物最多的个数进行求和
（初始值）（局部操作，全局操作）
pairRDD.aggregateByKey(0)(math.max(_,_),_+_).collect

7. foldByKey:对相同key进行聚合操作
foldByKey(初始值)（对value的操作）
拼接相同key的value字符串
val rdd1 = sc.parallelize(List("dog", "wolf", "cat", "bear"), 2)
val rdd2 = rdd1.map(x => (x.length, x))
val rdd3 = rdd2.foldByKey("")(_+_)
结果：Array[(Int, String)] = Array((4,wolfbear), (3,dogcat))

8. combineByKey 操作的是key-value
val rdd3 = rdd1.combineByKey(x => x + 10, (a: Int, b: Int) => a + b, (m: Int, n: Int) => m + n)

第一个参数:List(_),（分区的每一个元素：它的类型就是整个函数的返回类型（List[String]））
第二参数 (x: List[String], y: String=> x :+ y,)：分区内的局部聚合，x与第一个参数的返回类型一致，y是RDD的每一个value
第三个参数（(m: List[String], n: List[String]) => m ++ n）： 全局聚合，类型与第一个参数一致
val rdd7 = rdd6.combineByKey(List(_), (x: List[String], y: String) => x :+ y, (m: List[String], n: List[String]) => m ++ n)

9. coalesce、repartition、partitionBy:重新分区
coalesce：默认不会shuffle，可以重新分更小的分区，不能分更大的分区，如果要shuffle，需要传入参数true
val rdd1 = sc.parallelize(1 to 10, 5)
val rdd2 = rdd1.coalesce(10, true)
rdd2.partitions.length
repartition: 会进行shuffle，任意分区都可以，传入参数是Int数字
rdd1.repartition(8)
partitionBy:会进行shuffle,任意分区都可以，传入参数是分区器
rdd1.partitionBy(new org.apache.spark.HashPartitioner(7))

10. countByKey 计算相同key的元组有多少个
countByValue：计算相同value的元组有多少个
val rdd1 = sc.parallelize(List(("a", 1), ("b", 2), ("b", 2), ("c", 2), ("c", 1)))
rdd1.countByKey
rdd1.countByValue

11. filterByRange ：根据key的范围进行过滤
val rdd1 = sc.parallelize(List(("e", 5), ("f",2),("c", 3), ("d", 4), ("c", 2), ("a", 1)))
取出c到d范围的元组
val rdd2 = rdd1.filterByRange("c", "d")
rdd2.colllect

12. flatMapValues ：对元组的值进行操作并压平
val rdd3 = sc.parallelize(List(("a","1 2"), ("b","3 4")))
rdd3.flatMapValues(_.split(" ")).collect
结果： Array[(String, String)] = Array((a,1), (a,2), (b,3), (b,4))

13. foreachPartition ：对每个分区的操作，返回每个分区的结果
val rdd1 = sc.parallelize(List(1, 2, 3, 4, 5, 6, 7, 8, 9), 3)
rdd1.foreachPartition(x => println(x.reduce(_ + _)))
结果
6
15
24

14. keyBy ： 将传入的参数作为元组的key，原RDD元素作为value
val rdd1 = sc.parallelize(List("dog", "salmon", "salmon", "rat", "elephant"), 3)
val rdd2 = rdd1.keyBy(_.length)
rdd2.collect
结果：Array[(Int, String)] = Array((3,dog), (6,salmon), (6,salmon), (3,rat), (8,elephant))

15. keys ：获取RDD的key
values ：获取RDD的value
val rdd1 = sc.parallelize(List("dog", "tiger", "lion", "cat", "panther", "eagle"), 2)
val rdd2 = rdd1.map(x => (x.length, x))
rdd2.keys.collect
rdd2.values.collect

16. collectAsMap ：将集合转化成元组
val rdd = sc.parallelize(List(("a", 1), ("b", 2)))
rdd.collectAsMap
结果 ：scala.collection.Map[String,Int] = Map(b -> 2, a -> 1)
Spark算子综合案例 - Scala篇
weixin_51439828的博客
04-22 1535
补充完代码后，点击测评，平台会对你编写的代码进行测试，当你的结果与预期输出一致时，即为通过。//2.切分压平、直接好友拼接加入集合、遍历、间接好友拼接、返回集合。//4判断每一行里如果为直接好友将其次数设为0，如果不是+1。//5过滤掉次数为0的剩下的就是间接好友及其次数。区域内进行代码补充，完成统计间接好友的数量的程序。else ("直接好友", 0)请仔细阅读右侧代码，根据方法内的提示，在。知识完成 " 好友推荐 " 的程序。数据说明（第二行为例）： 这个人叫。在间接好友关系中出现的次数为。
头歌-Spark算子 - JAVA版本
bzzb52的博客
06-21 988
【代码】头歌-Spark算子 - JAVA版本。
算子理论基础知识
01-16
北邮 算子理论 课程ppt集合 超级有用哦 算子：人们试图用统一的方法去处理经 典分析中各领域分散研究的一些问题， 比如：变分法，积分方程，正交函数 系，逼近论等。 • 算子理论用抽象的形式和统一的方法对 一些表面上看起来很不相同的对象进行 加工，不仅使经典的分析中的概念更加 一般化，而且能够富有成效地解决问题。
算子
xyycw的专栏
10-18 877
微积分里的符号 算子是表示一种对函数的运算的符号。　　如同普通的运算符号作用于数后可以得到新的数那样，一个算子作用于一个函数后可以根据一定的规则生成一个新的函数。常见的算子有D(微分算子)，∫(不定积分算子)，grad(梯度算子)，∇(散度算子),△(拉普拉斯算子)等。它们的定义分别为：　　D(f) = f'　　∫(f) = F，F为f的原函数　　grad(f) = [df/dx1,df/dx2,...,df/dxn]，其中f=f(x1,x2,...,xn)为n元标量函数　　∇f = grad•f = d
Java Spark算子：sample
01-07
import org.apache.spark.... * sample(withReplacement,fraction,seed) 算子 * 对RDD中的数据进行随机采样，会有误差。 * 第一个参数：boolean类型，表示产生的样本是否可以重复：false不重复，也就是不放回的取；t
25个经典Spark算子的JAVA实现
08-16
根据给定文件的信息，本文将详细介绍25个经典Spark算子的Java实现，并结合详细的注释及JUnit测试结果，帮助读者更好地理解Spark算子的工作原理及其应用方式。 ### Spark算子简介 在Apache Spark框架中，算子是用于...
经典Spark算子的JAVA实现.zip
07-02
本资料“经典Spark算子的JAVA实现.zip”提供了25个核心Spark算子的Java实现，这些实现已经过Junit测试，确保了代码的正确性和可靠性。以下是对这些算子的详细介绍： 1. **map()**: 这是Spark中最基本的转换操作，它...
算子是什么
顺其自然~专栏
03-30 3872
在知道什么是算子之前我们还需要知道一些其他的相关概念，大概来说，算子是一个函数空间到函数空间上的映射O：X→X。广义上的算子可以推广到任何空间，如内积空间等。映射从一个拓扑空间到另一个拓扑空间的对应关系。对于每一个x，都有唯一的y与之对应。如果对于一个x，对应一个“集合”，而非唯一的一个y，这种对应关系称为“集值映射”。映射的概念是最一般的。对于映射的操作，最典型的是同伦。对于集值映射，最有名的结果是Kakutani不动点定理及其在博弈论和最优化中的应用。这些内容都属于拓扑学。集值映射和映射统称为对应。对应
什么是“算子”
crazyjinks的博客
04-10 3595
了解基本概念，什么是算子
算子的含义
LEOZHYD的博客
08-18 620
Transform: 1. map:rdd中的每项数据进行map里的操作后，会形成一个个新的元素的新rdd flatMap:在map的基础上进行扁平化，形成一个新的rdd 2. distinct:转换操作，去重 filter:对rdd中的元素进行过滤 filterByRange:范围过滤，作用于键值对RDD，对RDD中元素进行过滤，返回键在指定范围内的元素 3. union:并集操作，不去重 intersection:交集操作，去重 subtract:类似intersection，返回在rdd中出...
什么是算子？
华为云官方博客
06-25 1万+
本文介绍什么是算子，算子有哪些基本特征。
什么是算子?
热门推荐
冷色调的夏天的博客
09-22 4万+
什么是算子? 在知道什么是算子之前我们还需要知道一些其他的相关概念，大概来说，算子是一个函数空间到函数空间上的映射O：X→X。广义上的算子可以推广到任何空间，如内积空间等。 映射: 从一个拓扑空间到另一个拓扑空间的对应关系。对于每一个x，都有唯一的y与之对应。如果对于一个x，对应一个“集合”，而非唯一的一个y，这种对应关系称为“集值映射”。 映射的概念是最一般的。对于映射的操作，最典型的是...
Spark学习笔记四：算子
ximibbb的博客
03-04 447
一、什么是算子 算子是RDD中定义的函数，可以对RDD中的数据进行转换和操作（transformation和action） transformation不触发提交作业；action出发SparkContext提交Job作业 二、常用算子不完全归纳 Transformation转换操作 基础转换操作 map、mapPartitions、mapPartitionsWithIndex disti...
算子：详细篇
weixin_61070671的博客
01-23 1610
使用用户定义的 Partitioner 为每个元素选择目标任务。Scala如果我们想将数据存储到我们自己的存储设备中，而Flink并没有提供可以直接使用的连接器，就只能自定义Sink进行输出了。与Source类似，Flink为我们提供了通用的SinkFunction接口和对应的RichSinkDunction抽象类，只要实现它，通过简单地调用DataStream的.addSink()方法就可以自定义写入任何外部存储。
第1章 实践基础——算子
qq_62640789的博客
07-23 2358
算子（operator）是构建复杂机器学习模型的基础组件，包含一个函数的前向函数和反向函数,即函数在机器学习代码中定义为一个算子。有了算子，我们就可以很方便地通过算子来搭建复杂的神经网络模型，而不需要手工计算梯度...
【Halcon】算子介绍
Y忍冬草
08-18 1063
学习—》实践—》复盘 如此不断循环往复，才能有所突破！ ———Y忍冬草  记录下自己使用Halcon中遇到的一些简单但实用的算子，以备查看。 ...
spark算子
最新发布
03-17
### Spark算子概述 Spark 是一种分布式计算框架，其核心概念之一是 **RDD（弹性分布式数据集）**。通过一系列的转换操作（Transformation），可以构建复杂的并行计算流程。最终可以通过行动操作（Action）触发实际的任务执行。 以下是常见的 Spark 算子分类及其使用方法： --- #### 转换算子（Transformation） ##### `map` 将输入中的每一个元素应用指定函数，并返回一个新的 RDD。 ```python rdd = sc.parallelize([1, 2, 3]) mapped_rdd = rdd.map(lambda x: x * 2) print(mapped_rdd.collect()) # 输出: [2, 4, 6] ``` ##### `filter` 过滤掉不满足条件的数据项。 ```python filtered_rdd = rdd.filter(lambda x: x % 2 == 0) print(filtered_rdd.collect()) # 输出: [2] ``` ##### `flatMap` 类似于 map，但是会将结果扁平化处理。 ```python words = ["hello world", "this is a test"] flat_mapped_rdd = sc.parallelize(words).flatMap(lambda line: line.split()) print(flat_mapped_rdd.collect()) # 输出: ['hello', 'world', 'this', 'is', 'a', 'test'] ``` ##### `repartition` 重新分配分区数量，可能引发 Shuffle 操作。 ```python rep_rdd = rdd.repartition(4) # 将分区数调整为4 print(rep_rdd.getNumPartitions()) # 输出: 4 ``` 此过程涉及 Shuffle 的实现细节可参见[^3]。 --- #### 行动算子（Action） ##### `reduce` 对 RDD 中的所有元素进行两两聚合运算。 ```python sum_result = rdd.reduce(lambda x, y: x + y) print(sum_result) # 输出: 7 ``` ##### `collect` 将整个 RDD 收集到驱动程序中作为列表返回。 ```python collected_data = rdd.collect() print(collected_data) # 输出: [1, 2, 3] ``` ##### `count` 统计 RDD 中的元素总数。 ```python cnt = rdd.count() print(cnt) # 输出: 3 ``` ##### `take` 获取前 N 个元素。 ```python taken_elements = rdd.take(2) print(taken_elements) # 输出: [1, 2] ``` --- #### Join 类型算子 ##### `join` 和 `leftOuterJoin` 用于两个键值对类型的 RDD 进行连接操作。 ```python rdd1 = sc.parallelize([(1, "Apple"), (2, "Banana")]) rdd2 = sc.parallelize([(2, "Yellow"), (3, "Red")]) joined_rdd = rdd1.join(rdd2) print(joined_rdd.collect()) # 输出 [(2, ('Banana', 'Yellow'))] outer_joined_rdd = rdd1.leftOuterJoin(rdd2) print(outer_joined_rdd.collect()) # 结果示例可见于[^4] ``` --- #### 自定义算子 在 Java 或 Scala 中自定义算子时，通常需要继承特定接口并重写方法。例如，在 Java 中实现 Filter 功能： ```java JavaRDD<String> filteredRdd = rdd.filter(new Function<String, Boolean>() { public Boolean call(String row) throws Exception { return !row.isEmpty(); // 只保留非空字符串 } }); ``` 上述逻辑也可扩展至其他复杂场景下，具体实现方式详见[^2]。 --- ### 总结 以上展示了部分常用的 Spark 算子以及它们的应用实例。每种算子都有独特的用途和性能特点，合理选择能够显著提升作业效率。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值