RDD算子2

最新推荐文章于 2024-06-20 10:30:00 发布
最新推荐文章于 2024-06-20 10:30:00 发布
阅读量174 收藏
点赞数
分类专栏： Spark 大数据学习笔记 文章标签： spark RDD
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nuc2015/article/details/82355546
版权

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)

 

nuc2015
关注
专栏目录
Spark基础学习笔记17：掌握RDD算子
howard2005的专栏
03-12 2548
RDD转化算子、RDD行动算子
Spark学习笔记11:RDD算子
balabalalibala的博客
05-20 1050
RDD 算子
Spark 总结之RDD(二)
xiaohu21的博客
09-20 330
Spark 总结之RDD(二) 1. 背景 Spark作为分布式数据处理引擎,在企业实践中大量应用.对比Mapreduce既有性能上的优势,也有开发编程上的便捷性优势. Spark针对数据处理,对编程接口做了更高层级的抽象和封装,API使用起来更加方便.其中RDD DataSet DataFrame DStream等都是抽象出来的数据处理对象. RDD使用时会屏蔽掉具体细节,操作起来就跟操作Scala的集合对象一样便捷. 2. RDD常见算子和方法 2.1 RDD创建 查看方法 RDD创建
Spark RDD算子源码解读
tanglizhe1105的博客
11-02 3465
结合spark1.5.0的RDD源码API及自己一年以来的开发经验，介绍Spark RDD算子的功能、原理及调用方式。
SPARK RDD基础及常用算子浅谈
welson650的博客
05-17 418
SPARK RDD基础及常用算子浅谈 一、什么是SPARK RDD:       RDD是将数据项拆分为多个分区的集合，存储在集群的工作节点上的内存中，并执行正确的操作。RDD是用于数据转换的接口。RDD指向了存储在HDFS、Cassandra、HBase等、或缓存（内存、内存+磁盘、仅磁盘等），或在故障或缓存收回时重新计算其他RDD分区中的数据。       RDD是弹性分布式数据集（R
Spark 简单实例（基本操作）
何成俭的博客
06-02 2935
目录[-] 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
Spark之RDD算子
柳小葱的博客
08-11 2096
今天出一期spark系列的硬货，即RDD算子，所谓算子，就是对某些事物的操作，或者说是方法。本期主要介绍几十个RDD算子，根据他们的特点，逐一进行介绍，有关spark的往期内容大家可以查看下面的内容????: 链接: Spark之处理布尔、数值和字符串类型的数据. 链接: Spark之Dataframe基本操作. 链接: Spark之处理布尔、数值和字符串类型的数据. 链接: Spark之核心架构. 记得我们前面说过，saprk存在着惰性评估的机制，所谓惰性评估，就是等到绝对需要时才执行计算。当用户表达
Spark-RDD算子大全
YoungITの博客
01-16 939
Spark RDD（弹性分布式数据集）是Spark中的核心抽象，它代表一个不可变、分区的分布式数据集合。下面是一些常用的RDD算子：map(func)：对RDD中的每个元素应用给定的函数，返回一个新的RDD。filter(func)：对RDD中的每个元素应用给定的函数，返回满足条件的元素组成的新的RDD。flatMap(func)：对RDD中的每个元素应用给定的函数并返回一个迭代器，将所有迭代器的元素组合成一个新的RDD。
RDD 算子
McGrady_Durant的博客
08-11 1452
对RDD操作，可以通过spark提供的算子完成 在spark提供的对RDD操作的算子中，分成了两类： **转换算子(transfermation): ** 从-一个RDD,经过算子处理转换成另外一个RDD。 行动算子(Action): 从一个RDD，经过算子处理，会生成一个scala对象。 转换算子是懒加载模式，只有遇到了行动算子，转换算子才会真正执行 RDD转换（Transformations）算子 转换算子(transfermation) 分成了两部分: 1.对值（value）进行操作的算子 2.对
RDD算子介绍（一）
weixin_46628668的博客
03-02 1142
转换，即一个RDD转换为另一个RDD，是功能的转换与补充，比如map，flatMap。sample算子主要有三个参数，第一个是抽取的数放不放回去，第二个参数是概率，如果抽取不放回，则表示每个数被抽取的概率，如果抽取放回，则表示某个数可能的抽取次数（可能的次数而已），第三个参数是随机数算法种子（一般可不填，如果填了，可能会导致抽取结果固定）。所以，RDD的计算对于分区内的数据是一个个执行的，即分区内数据的执行是有序的，但是分区间的数据执行是无序的。，原分区的数据被分到另一个分区了，即。
Spark RDD算子详解
weixin_36040866的博客
02-07 3718
RDD转换算子及行动算子详细记录，附idea实操演练 转换算子（Transformation）：功能的补充和封装，将旧的RDD包装成新的RDD（flatMap,map...) 行动算子（Action）：触发任务的调度和作业的执行(collect)
Spark RDD算子
weixin_61676991的博客
06-20 3013
​ reduceByKey()算子的作用对象是元素为(key,value)形式（Scala元组）的RDD，使用该算子可以将key相同的元素聚集到一起，最终把所有key相同的元素合并成一个元素。​ rightOuterJoin()算子的使用方法与leftOuterJoin()算子相反，其与数据库的右外连接类似，以右边的RDD为基准（例如rdd1.rightOuterJoin(rdd2)，以rdd2为基准），右边RDD的记录一定会存在。Spark会将RDD中的每个元素传入该函数的参数中。
RDD算子
weixin_41812379的博客
10-30 714
RDD 的操作分为转化（Transformation）操作和行动（Action）操作。转化操作就是从一个 RDD 产生一个新的 RDD，而行动操作就是进行实际的计算。转换操作和行动操作一般也被叫做转换算子和行动算子。 RDD 的操作是惰性的，当 RDD 执行转化操作的时候，实际计算并没有被执行，只有当 RDD 执行行动操作时才会促发计算任务提交，从而执行相应的计算操作。 RDD转换算子 首先，我们需要理解一件事。这种算子所输入的往往是一个或多个函数，这个函数用来对转换算子所指定的数据做具体处理。例如： //
RDD算子介绍
xiaoc1008的博客
11-29 1439
rdd1 = sc.parallelize([('c01','张三'),('c02','李四'),('c02','王五'),('c01','赵六'),('c03','田七'),('c03','周八'),('c02','李九'),('c04','老张')])输入: rdd = sc.parallelize([('c01','张三'),('c02','李四'),('c02','王五'),('c01','赵六'),('c03','田七'),('c03','周八'),('c02','李九')])
Spark核心编程—RDD算子(转换算子)
weixin_42570840的博客
06-13 1803
Spark核心编程、RDD转换算子
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 8170
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 6822
将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 5448
Master结点存在单点故障，所以要借助zookeeper，至少启动两台Master结点来实现高可用，配置方案比较简单 先停止所有Spark服务，然后安装zookeeper，并启动zookeeper 集群规划： 主机名 IP地址 启动程序 master.hadoop 192.168.1.2 zookeeper、master、worker slave1.hado...
spark RDD算子
最新发布
08-10
RDD算子（Operators）是处理RDD的基本操作单元，它们用于对数据进行转换和动作。Spark提供了一系列的内置算子，可以分为两类： 1. **转换（Transformation）算子**：这类算子不会直接改变原始数据集，而是返回一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值