spark算子

Spark基础学习笔记16:创建RDD RDD概念,创建RDD 阅读详情
    <div id="post_detail" class="cye-lm-tag">

Spark算子总结及案例

spark算子大致上可分三大类算子:

  1、Value数据类型的Transformation算子,这种变换不触发提交作业,针对处理的数据项是Value型的数据。

  2、Key-Value数据类型的Transformation算子,这种变换不触发提交作业,针对处理的数据项是Key-Value型的数据。

  3、Action算子,这类算子会触发SparkContext提交作业。

一、Value型Transformation算子

1)map

val a = sc.parallelize(List("dog", "salmon", "salmon", "rat", "elephant"), 3)
val b = a.map(_.length)
val c = a.zip(b)
c.collect
res0: Array[(String, Int)] = Array((dog,3), (salmon,6), (salmon,6), (rat,3), (elephant,8))

2)flatMap

复制代码
val a = sc.parallelize(1 to 10, 5)
a.flatMap(1 to _).collect
res47: Array[Int] = Array(1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

sc.parallelize(List(1, 2, 3), 2).flatMap(x => List(x, x, x)).collect
res85: Array[Int]
= Array(1, 1, 1, 2, 2, 2, 3, 3, 3)

复制代码

3)mapPartiions

val x  = sc.parallelize(1 to 10, 3)
x.flatMap(List.fill(scala.util.Random.nextInt(10))(_)).collect

res1: Array[Int] = Array(1, 2, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10)

4)glom(形成一个Array数组)

复制代码
val a = sc.parallelize(1 to 100, 3)
a.glom.collect
res8: Array[Array[Int]] = Array(Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33), Array(34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66), Array(67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100))
复制代码

5)union

val a = sc.parallelize(1 to 3, 1)
val b = sc.parallelize(5 to 7, 1)
(a ++ b).collect
res0: Array[Int] = Array(1, 2, 3, 5, 6, 7)

6)cartesian(笛卡尔操作)

val x = sc.parallelize(List(1,2,3,4,5))
val y = sc.parallelize(List(6,7,8,9,10))
x.cartesian(y).collect
res0: 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))

7)groupBy(生成相应的key,相同的放在一起)

val a = sc.parallelize(1 to 9, 3)
a.groupBy(x => { if (x % 2 == 0) "even" else "odd" }).collect
res42: Array[(String, Seq[Int])] = Array((even,ArrayBuffer(2, 4, 6, 8)), (odd,ArrayBuffer(1, 3, 5, 7, 9)))

8)filter

val a = sc.parallelize(1 to 10, 3)
val b = a.filter(_ % 2 == 0)
b.collect
res3: Array[Int] = Array(2, 4, 6, 8, 10)

9)distinct(去重)

val c = sc.parallelize(List("Gnu", "Cat", "Rat", "Dog", "Gnu", "Rat"), 2)
c.distinct.collect
res6: Array[String] = Array(Dog, Gnu, Cat, Rat)

10)subtract(去掉含有重复的项)

val a = sc.parallelize(1 to 9, 3)
val b = sc.parallelize(1 to 3, 3)
val c = a.subtract(b)
c.collect
res3: Array[Int] = Array(6, 9, 4, 7, 5, 8)

11)sample

val a = sc.parallelize(1 to 10000, 3)
a.sample(false, 0.1, 0).count
res24: Long = 960

12)takesample

复制代码
val x = sc.parallelize(1 to 1000, 3)
x.takeSample(true, 100, 1)
res3: Array[Int] = Array(339, 718, 810, 105, 71, 268, 333, 360, 341, 300, 68, 848, 431, 449, 773, 172, 802, 339, 431, 285, 937, 301, 167, 69, 330, 864, 40, 645, 65, 349, 613, 468, 982, 314, 160, 675, 232, 794, 577, 571, 805, 317, 136, 860, 522, 45, 628, 178, 321, 482, 657, 114, 332, 728, 901, 290, 175, 876, 227, 130, 863, 773, 559, 301, 694, 460, 839, 952, 664, 851, 260, 729, 823, 880, 792, 964, 614, 821, 683, 364, 80, 875, 813, 951, 663, 344, 546, 918, 436, 451, 397, 670, 756, 512, 391, 70, 213, 896, 123, 858)
复制代码

13)cache、persist

复制代码
val c = sc.parallelize(List("Gnu", "Cat", "Rat", "Dog", "Gnu", "Rat"), 2)
c.getStorageLevel
res0: org.apache.spark.storage.StorageLevel = StorageLevel(false, false, false, false, 1)
c.cache
c.getStorageLevel
res2: org.apache.spark.storage.StorageLevel = StorageLevel(false, true, false, true, 1)
复制代码

二、Key-Value型Transformation算子

1)mapValues

val a = sc.parallelize(List("dog", "tiger", "lion", "cat", "panther", "eagle"), 2)
val b = a.map(x => (x.length, x))
b.mapValues("x" + _ + "x").collect
res5: Array[(Int, String)] = Array((3,xdogx), (5,xtigerx), (4,xlionx), (3,xcatx), (7,xpantherx), (5,xeaglex))

2)combineByKey

复制代码
val a = sc.parallelize(List("dog","cat","gnu","salmon","rabbit","turkey","wolf","bear","bee"), 3)
val b = sc.parallelize(List(1,1,2,2,2,1,2,2,2), 3)
val c = b.zip(a)
val d = c.combineByKey(List(_), (x:List[String], y:String) => y :: x, (x:List[String], y:List[String]) => x ::: y)
d.collect
res16: Array[(Int, List[String])] = Array((1,List(cat, dog, turkey)), (2,List(gnu, rabbit, salmon, bee, bear, wolf)))
复制代码

3)reduceByKey

复制代码
val a = sc.parallelize(List("dog", "cat", "owl", "gnu", "ant"), 2)
val b = a.map(x => (x.length, x))
b.reduceByKey(_ + _).collect
res86: Array[(Int, String)] = Array((3,dogcatowlgnuant))

val a = sc.parallelize(List(“dog”, “tiger”, “lion”, “cat”, “panther”, “eagle”), 2)
val b
= a.map(x => (x.length, x))
b.reduceByKey(_
+ _).collect
res87: Array[(Int, String)]
= Array((4,lion), (3,dogcat), (7,panther), (5,tigereagle))

复制代码

4)partitionBy

(对RDD进行分区操作)

5)cogroup

复制代码
val a = sc.parallelize(List(1, 2, 1, 3), 1)
val b = a.map((_, "b"))
val c = a.map((_, "c"))
b.cogroup(c).collect
res7: Array[(Int, (Iterable[String], Iterable[String]))] = Array(
(2,(ArrayBuffer(b),ArrayBuffer(c))),
(3,(ArrayBuffer(b),ArrayBuffer(c))),
(1,(ArrayBuffer(b, b),ArrayBuffer(c, c)))
)
复制代码

6)join

复制代码
val a = sc.parallelize(List("dog", "salmon", "salmon", "rat", "elephant"), 3)
val b = a.keyBy(_.length)
val c = sc.parallelize(List("dog","cat","gnu","salmon","rabbit","turkey","wolf","bear","bee"), 3)
val d = c.keyBy(_.length)
b.join(d).collect

res0: Array[(Int, (String, String))] = Array((6,(salmon,salmon)), (6,(salmon,rabbit)), (6,(salmon,turkey)), (6,(salmon,salmon)), (6,(salmon,rabbit)), (6,(salmon,turkey)), (3,(dog,dog)), (3,(dog,cat)), (3,(dog,gnu)), (3,(dog,bee)), (3,(rat,dog)), (3,(rat,cat)), (3,(rat,gnu)), (3,(rat,bee)))

复制代码

7)leftOutJoin

复制代码
val a = sc.parallelize(List("dog", "salmon", "salmon", "rat", "elephant"), 3)
val b = a.keyBy(_.length)
val c = sc.parallelize(List("dog","cat","gnu","salmon","rabbit","turkey","wolf","bear","bee"), 3)
val d = c.keyBy(_.length)
b.leftOuterJoin(d).collect

res1: Array[(Int, (String, Option[String]))] = Array((6,(salmon,Some(salmon))), (6,(salmon,Some(rabbit))), (6,(salmon,Some(turkey))), (6,(salmon,Some(salmon))), (6,(salmon,Some(rabbit))), (6,(salmon,Some(turkey))), (3,(dog,Some(dog))), (3,(dog,Some(cat))), (3,(dog,Some(gnu))), (3,(dog,Some(bee))), (3,(rat,Some(dog))), (3,(rat,Some(cat))), (3,(rat,Some(gnu))), (3,(rat,Some(bee))), (8,(elephant,None)))

复制代码

8)rightOutJoin

复制代码
val a = sc.parallelize(List("dog", "salmon", "salmon", "rat", "elephant"), 3)
val b = a.keyBy(_.length)
val c = sc.parallelize(List("dog","cat","gnu","salmon","rabbit","turkey","wolf","bear","bee"), 3)
val d = c.keyBy(_.length)
b.rightOuterJoin(d).collect

res2: Array[(Int, (Option[String], String))] = Array((6,(Some(salmon),salmon)), (6,(Some(salmon),rabbit)), (6,(Some(salmon),turkey)), (6,(Some(salmon),salmon)), (6,(Some(salmon),rabbit)), (6,(Some(salmon),turkey)), (3,(Some(dog),dog)), (3,(Some(dog),cat)), (3,(Some(dog),gnu)), (3,(Some(dog),bee)), (3,(Some(rat),dog)), (3,(Some(rat),cat)), (3,(Some(rat),gnu)), (3,(Some(rat),bee)), (4,(None,wolf)), (4,(None,bear)))

复制代码

三、Actions算子

1)foreach

复制代码
val c = sc.parallelize(List("cat", "dog", "tiger", "lion", "gnu", "crocodile", "ant", "whale", "dolphin", "spider"), 3)
c.foreach(x => println(x + "s are yummy"))
lions are yummy
gnus are yummy
crocodiles are yummy
ants are yummy
whales are yummy
dolphins are yummy
spiders are yummy
复制代码

2)saveAsTextFile

val a = sc.parallelize(1 to 10000, 3)
a.saveAsTextFile("mydata_a")
14/04/03 21:11:36 INFO FileOutputCommitter: Saved output of task 'attempt_201404032111_0000_m_000002_71' to file:/home/cloudera/Documents/spark-0.9.0-incubating-bin-cdh4/bin/mydata_a

3)saveAsObjectFile

复制代码
val x = sc.parallelize(1 to 100, 3)
x.saveAsObjectFile("objFile")
val y = sc.objectFile[Int]("objFile")
y.collect
res52: Array[Int] =  Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100)
复制代码

4)collect

val c = sc.parallelize(List("Gnu", "Cat", "Rat", "Dog", "Gnu", "Rat"), 2)
c.collect
res29: Array[String] = Array(Gnu, Cat, Rat, Dog, Gnu, Rat)

5)collectAsMap

val a = sc.parallelize(List(1, 2, 1, 3), 1)
val b = a.zip(a)
b.collectAsMap
res1: scala.collection.Map[Int,Int] = Map(2 -> 2, 1 -> 1, 3 -> 3)

6)reduceByKeyLocally

val a = sc.parallelize(List("dog", "cat", "owl", "gnu", "ant"), 2)
val b = a.map(x => (x.length, x))
b.reduceByKey(_ + _).collect
res86: Array[(Int, String)] = Array((3,dogcatowlgnuant))

7)lookup

val a = sc.parallelize(List("dog", "tiger", "lion", "cat", "panther", "eagle"), 2)
val b = a.map(x => (x.length, x))
b.lookup(5)
res0: Seq[String] = WrappedArray(tiger, eagle)

8)count

val c = sc.parallelize(List("Gnu", "Cat", "Rat", "Dog"), 2)
c.count
res2: Long = 4

9)top

val c = sc.parallelize(Array(6, 9, 4, 7, 5, 8), 2)
c.top(2)
res28: Array[Int] = Array(9, 8)

10)reduce

val a = sc.parallelize(1 to 100, 3)
a.reduce(_ + _)
res41: Int = 5050

11)fold

val a = sc.parallelize(List(1,2,3), 3)
a.fold(0)(_ + _)
res59: Int = 6

12)aggregate

复制代码
val z = sc.parallelize(List(1,2,3,4,5,6), 2)

// lets first print out the contents of the RDD with partition labels
def myfunc(index: Int, iter: Iterator[(Int)]) : Iterator[String] = {
iter.toList.map(x
=> “[partID:” + index + ", val: " + x + “]”).iterator
}

z.mapPartitionsWithIndex(myfunc).collect
res28: 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])

z.aggregate(0)(math.max(_, _), _ + _)
res40: Int
= 9

复制代码

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

当神已无能为力,那便是魔渡众生
分类: Spark
3
0
« 上一篇: Linux在线安装git(亲测成功)
» 下一篇: Spark(1.0)内核解析
	</div>
	<div class="postDesc">posted @ <span id="post-date" class="cye-lm-tag">2016-03-16 22:56</span> <a href="https://www.cnblogs.com/liuzhongfeng/">liurio</a> 阅读(<span id="post_view_count" class="cye-lm-tag">12239</span>) 评论(<span id="post_comment_count" class="cye-lm-tag">0</span>)  <a href="https://i.cnblogs.com/EditPosts.aspx?postid=5285613" rel="nofollow">编辑</a> <a href="#" onclick="AddToWz(5285613);return false;">收藏</a></div>
</div>
<script type="text/javascript">var allowComments=true,cb_blogId=259623,cb_entryId=5285613,cb_blogApp=currentBlogApp,cb_blogUserGuid='5444e354-22a7-e511-9fc1-ac853d9f53cc',cb_entryCreatedDate='2016/3/16 22:56:00';loadViewCount(cb_entryId);var cb_postType=1;var isMarkdown=false;</script>
</div>
Multisim 14.0元件库下载权威指南:官方与社区资源 详解Multisim元件库下载的官方途径与可靠社区资源,帮助用户快速获取Multisim 14.0所需元件模型,提升电路仿真效率。 阅读详情

相关推荐

Lmbench测试集 --- 延迟测试工具lat_mem_rd

lmbench测试集简介 以及 lat_mem_rd延迟测试工具: 如何测试、测试结果、源码分析

MonologueYY的博客 1万+

一文学完Spark常用算子(Spark算子大全)

Spark RDD的算子分为转换算子(Transformation)和行动算子(Action)。转换算子分为:Value类型、双Value类型和K-V类型。将处理的数据逐条进行映射转换,这里的转换可以是类型的转换,也可以是值的转换...............

笑看风云路的博客 9171

C++ 工程实践(9):数据抽象

陈硕 (giantchen_AT_gmail)http://blog.youkuaiyun.com/Solstice  http://weibo.com/giantchen陈硕关于 C++ 工程实践的系列文章: http://blog.youkuaiyun.com/Solstice/category/8

陈硕的Blog 1万+

Spark常见算子详解

groupByKey 和groupby 的区别是前者是确定以key为分组,所以只返回value的迭代器,程序上后者不确定以什么来分组,所以返回[(String,Int) (K,V)]定义:countByKey算子统计K-v类型的数据中的Key的次数,countByValue统计所有的value出现的次数,统计对象可以是K-v,也可以是List等。定义:rdd.aggregateByKey((初始化的值)(分区内迭代计算的逻辑)(分区间计算的逻辑))

weixin_42733117的博客 3070

【ChatGPT实战案例】ChatGPT如何帮助产品经理高效工作?

1. 产品经理主要工作方向, 2. 具体工作中,向ChatGPT提问参考

weixin_62909516的博客 1899

Qwen2.5-VL模型微调实战:从零到部署的完整流程(附避坑指南)

本文详细介绍了Qwen2.5-VL视觉语言模型从零开始的完整微调与部署流程。内容涵盖使用LLaMA-Factory进行LoRA微调的关键参数配置与避坑指南,以及如何将训练好的模型权重合并,并最终利用vLLM高性能推理引擎进行部署,为开发者提供了一套可落地的实战方案。

oo7890的博客 591

Spark常用算子详解

Spark的算子的分类   从大方向来说,Spark 算子大致可以分为以下两类:     1)Transformation 变换/转换算子:这种变换并不触发提交作业,完成作业中间过程处理。     Transformation 操作是延迟计算的,也就是说从一个RDD 转换生成另一个 RDD 的转换操作不是马上执行,需要等到有 Action 操作的时候才会真正触发运算。     2)Action...

StoneWords的博客 3万+

DBeaver连接IoTDB避坑指南:手动配置JDBC驱动的完整流程(附问题排查)

本文提供了在DBeaver中手动配置Apache IoTDB JDBC驱动的完整流程与避坑指南。详细解析了从驱动创建、库文件添加(关键是指向整个lib目录)到连接测试的每一步,并重点针对常见的ClassNotFoundException、连接拒绝等错误提供了深度排查方案,帮助用户高效建立图形化管理连接。

weixin_28327051的博客 395

Spark RDD算子

​ reduceByKey()算子的作用对象是元素为(key,value)形式(Scala元组)的RDD,使用该算子可以将key相同的元素聚集到一起,最终把所有key相同的元素合并成一个元素。​ rightOuterJoin()算子的使用方法与leftOuterJoin()算子相反,其与数据库的右外连接类似,以右边的RDD为基准(例如rdd1.rightOuterJoin(rdd2),以rdd2为基准),右边RDD的记录一定会存在。Spark会将RDD中的每个元素传入该函数的参数中。

weixin_61676991的博客 3221

别再只盯着Text-VQA了!这4个主流VQA数据集(含中英双语)的保姆级下载与对比指南

本文深入解析了Text-VQA、ST-VQA、OCR-VQA和EST-VQA这4个主流视觉问答数据集的特性与应用场景,提供了详细的下载与预处理指南。通过对比分析,帮助开发者根据项目需求选择最适合的数据集,避免因选型不当导致的模型性能问题,特别适合需要处理中英双语或多模态文本理解的AI项目。

weixin_42524708的博客 362

在Simulink中构建感应电机的时滞补偿控制模型,并通过仿真验证不同补偿策略的有效性

核心优势Smith预估器可有效补偿已知时滞,提升系统稳定性。动态PID调整适用于时变时滞的初步补偿。扩展方向自适应时滞估计:结合Luenberger观测器实时估计时滞。鲁棒控制:引入H∞控制或滑模控制抑制参数不确定性。网络化时滞补偿:结合知识库[2]的网络延迟模型,实现端到端补偿。

amy_mhd的博客 189

Spark 常用算子详解(转换算子、行动算子、控制算子)

Spark简介 Spark是专为大规模数据处理而设计的快速通用的计算引擎; Spark拥有Hadoop MapReduce所具有的优点,但是运行速度却比MapReduce有很大的提升,特别是在数据挖掘、机器学习等需要迭代的领域可提升100x倍的速度: Spark是基于内存进行数据处理的,MapReduce是基于磁盘进行数据处理的; Spark中具有DAG有向无环图,DAG有向无环图在此过程中减少...

weixin_44735572的博客 7099

【QNX+Android虚拟化方案】00 - 系列文章链接汇总

【QNX+Android虚拟化方案】00 - 系列文章链接汇总

|~~~热爱生活、努力学习的小伙汁~~~| 1万+

Spark算子

RDD的方法和Scala集合对象的方法不一样,集合对象的方法都是在同一个节点的内存中完成的。RDD的方法可以将计算逻辑发送到Executor端(分布式节点)执行。为了区分不同的处理效果,所以将RDD的方法称为算子,RDD的方法外部的操作都是在Driver端执行的,而方法内部的逻辑代码是在Executor端执行。Spark算子大致可以分为4类:创建算子、转换算子、缓存算子、行动算子。............

weixin_44328257的博客 2568

ssm框架搭建

这个是一个在idea上成功跑起来的ssm框架项目,保存在这里方便以后使用直接下载

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

Spark的算子

分享了spark中的算子

xieyichun_的博客 2258

温度PID控制PLC程序

温度PID稳定控制程序,适用于欧姆龙PLC,对其他PLC也具有很大参考价值

【精通Spark系列】Spark算子大合集,一文掌握spark中的常用转换与行动算子

RDD 中的算子从功能上分为两大类1.Transformation(转换算子) 它会在一个已经存在的 RDD 上创建一个新的 RDD,这也使得RDD之间存在了血缘关系与联系2.Action(动作算子) 执行各个分区的计算任务, 结果返回到 Driver 中特点1.Spark 中所有的 Transformations 是 惰性 的, 不会立即执行获得结果. 只会记录在数据集上要应用的操作.当需要返回结果给 Driver 时, 才会执行这些操作, 这个特性叫做 惰性求值。

大数据小禅的博客 2511

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

Spark中算子的总结

mapValues: 将所有的value拿到之后进行map转换,转换后还是元组,只是元组中的value,进行了变化。功能:对KV类型的RDD按照Key进行分组,相同K的Value放入一 个集合列表中,返回一个新的RDD。场景:需要对数据进行分组的场景,或者说分组以后的聚合逻辑 比较复杂,不适合用reduce。特点:必须经过Shuffle,可以指定新的RDD分区个数,可以指定分区规则。的RDD之间按照K实现关联,将两个RDD的关联结果放入一个新的RDD中。功能:调整RDD的分区个数 分类:转换算子。

A12345689B的博客 1178

【Spark】Spark的常用算子

使用给定的函数对 RDD 的元素进行聚合,seqOp 计算在分区中初始值到中间结果的聚合计算,而 combOp 在节点上对中间结果进行聚合。: 返回对输入 RDD 和参数 RDD 执行联合操作的结果,生成一个新的 RDD,不去重。: 返回对输入 RDD 和参数 RDD 执行交集操作的结果,生成一个新的 RDD。: 返回对输入 RDD 和参数 RDD 执行差集操作的结果,生成一个新的 RDD。: 返回对输入 RDD 和参数 RDD 执行笛卡尔积的结果,生成一个新的 RDD。

weixin_46429290的博客 3367

Spark 算子

RDD算子分类,大致可以分为两类,即: Transformation:转换算子,这类转换并不触发提交作业,完成作业中间过程处理。 Action:行动算子,这类算子会触发SparkContext提交Job作业。 一:Transformation:转换算子1.map map是对RDD中的每个元素都执行一个指定的函数来产生一个新的RDD。任何原RDD中的元素在新RDD中都有且只有一个元素与之对应。举例:

至道 1万+

Spark中的常见算子

Spark中的常见算子---触发算子、转换算子。哪些算子能触发shuffle过程

m0_56341622的博客 2319

Spark常用算子

Spark 算子大致可以分为以下三类: 1.Value数据类型的Transformation算子,这种变换并不触发提交作业,针对处理的数据项是Value型的数据。 2.Key-Value数据类型的Transfromation算子,这种变换并不触发提交 作业,针对处理的数据项是Key-Value型的数据对。 3.Action算子,这类算子会触发SparkContext提交Job作业 例子: 1、...

chenyh_csdn的博客 4538

spark算子汇总

spark算子汇总 Spark的算子的分类 从大方向来说,Spark 算子大致可以分为以下两类: 1)Transformation 变换/转换算子:这种变换并不触发提交作业,完成作业中间过程处理。 Transformation 操作是延迟计算的,也就是说从一个RDD 转换生成另一个 RDD 的转换操作不是马上执行,需要等到有 Action 操作的时候才会真正触发运算。 2)Action 行动算子:这类算子会触发 SparkContext 提交 Job 作业。 Action 算子会触发 Spark 提

weixin_43641478的博客 1579

Spark 行动算子

Spark 行动算子,方法

m0_72168501的博客 1052

Spark之RDD算子

今天出一期spark系列的硬货,即RDD算子,所谓算子,就是对某些事物的操作,或者说是方法。本期主要介绍几十个RDD算子,根据他们的特点,逐一进行介绍,有关spark的往期内容大家可以查看下面的内容????: 链接: Spark之处理布尔、数值和字符串类型的数据. 链接: Spark之Dataframe基本操作. 链接: Spark之处理布尔、数值和字符串类型的数据. 链接: Spark之核心架构. 记得我们前面说过,saprk存在着惰性评估的机制,所谓惰性评估,就是等到绝对需要时才执行计算。当用户表达

柳小葱的博客 2594
上一篇: 数据仓库中mysql,hive,hdfs,mapreduce之间的关系
下一篇: Spark运行基本流程
Alwaysdazz
博客等级 码龄8年 24粉丝 140原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值