【SparkCore】RDD常用方法以及使用

最新推荐文章于 2023-04-28 17:12:21 发布

没去过埃及的法老

最新推荐文章于 2023-04-28 17:12:21 发布

阅读量456

点赞数

分类专栏： Sprak 文章标签： SparkCore spark sparkapi 大数据云计算/大数据

本文链接：https://blog.csdn.net/qq_41369191/article/details/105972496

版权

Sprak 专栏收录该内容

24 篇文章 0 订阅

订阅专栏

创建RDD

1.由外部存储系统的数据集创建，包括本地的文件系统，还有所有Hadoop支持的数据集，比如HDFS、Cassandra、HBase等

2.通过已有的RDD经过算子转换生成新的RDD

创建RDD

1.由外部存储系统的数据集创建，包括本地的文件系统，还有所有Hadoop支持的数据集，比如HDFS、Cassandra、HBase等

val rdd1 = sc.textFile("hdfs://node01:8020/wordcount/input/words.txt")

2.通过已有的RDD经过算子转换生成新的RDD

val rdd1 = sc.textFile("hdfs://node01:8020/wordcount/input/words.txt") val rdd2=rdd1.flatMap(_.split(" "))

3.由一个已经存在的Scala集合创建

val rdd3 = sc.parallelize(Array(1,2,3,4,5,6,7,8)) //makeRDD方法底层调用了parallelize方法 val rdd4 = sc.makeRDD(List(1,2,3,4,5,6,7,8))

RDD的方法/算子分类

RDD的算子分为两类

Transformation：转换操作，返回一个新的RDD

Action：动作操作，返回值不是RDD(无返回值或返回其他的)

注意

RDD不实际存储真正要计算的数据，而是记录了数据的位置在哪里，数据的转换关系(调用了什么方法，传入什么函数)

RDD中的所有转换都是惰性求值/延迟执行的，也就是说并不会直接计算。只有当发生一个要求返回结果给Driver的Action动作时，这些转换才会真正运行。之所以使用惰性求值/延迟执行，是因为这样可以在Action时对RDD操作形成DAG有向无环图进行Stage的划分和并行优化，这种设计让Spark更加有效率地运行。

Transformation转换算子

转换	含义
map(func)	返回一个新的RDD，该RDD由每一个输入元素经过func函数转换后组成
filter(func)	返回一个新的RDD，该RDD由经过func函数计算后返回值为true的输入元素组成
flatMap(func)	类似于map，但是每一个输入元素可以被映射为0或多个输出元素(所以func应该返回一个序列，而不是单一元素)
mapPartitions(func)	类似于map，但独立地在RDD的每一个分片上运行，因此在类型为T的RDD上运行时，func的函数类型必须是Iterator[T] => Iterator[U]
mapPartitionsWithIndex(func)	类似于mapPartitions，但func带有一个整数参数表示分片的索引值，因此在类型为T的RDD上运行时，func的函数类型必须是 (Int, Interator[T]) => Iterator[U]
sample(withReplacement, fraction, seed)	根据fraction指定的比例对数据进行采样，可以选择是否使用随机数进行替换，seed用于指定随机数生成器种子
union(otherDataset)	对源RDD和参数RDD求并集后返回一个新的RDD
intersection(otherDataset)	对源RDD和参数RDD求交集后返回一个新的RDD
distinct([numTasks]))	对源RDD进行去重后返回一个新的RDD
groupByKey([numTasks])	在一个(K,V)的RDD上调用，返回一个(K, Iterator[V])的RDD
reduceByKey(func, [numTasks])	在一个(K,V)的RDD上调用，返回一个(K,V)的RDD，使用指定的reduce函数，将相同key的值聚合到一起，与groupByKey类似，reduce任务的个数可以通过第二个可选的参数来设置
aggregateByKey(zeroValue)(seqOp, combOp, [numTasks])
sortByKey([ascending], [numTasks])	在一个(K,V)的RDD上调用，K必须实现Ordered接口，返回一个按照key进行排序的(K,V)的RDD
sortBy(func,[ascending], [numTasks])	与sortByKey类似，但是更灵活
join(otherDataset, [numTasks])	在类型为(K,V)和(K,W)的RDD上调用，返回一个相同key对应的所有元素对在一起的(K,(V,W))的RDD
cogroup(otherDataset, [numTasks])	在类型为(K,V)和(K,W)的RDD上调用，返回一个(K,(Iterable<V>,Iterable<W>))类型的RDD
cartesian(otherDataset)	笛卡尔积
pipe(command, [envVars])	对rdd进行管道操作
coalesce(numPartitions)	减少 RDD 的分区数到指定值。在过滤大量数据之后，可以执行此操作
repartition(numPartitions)	重新给 RDD 分区

Action动作算子

动作	含义
reduce(func)	通过func函数聚集RDD中的所有元素，这个功能必须是可交换且可并联的
collect()	在驱动程序中，以数组的形式返回数据集的所有元素
count()	返回RDD的元素个数
first()	返回RDD的第一个元素(类似于take(1))
take(n)	返回一个由数据集的前n个元素组成的数组
takeSample(withReplacement,num, [seed])	返回一个数组，该数组由从数据集中随机采样的num个元素组成，可以选择是否用随机数替换不足的部分，seed用于指定随机数生成器种子
takeOrdered(n, [ordering])	返回自然顺序或者自定义顺序的前 n 个元素
saveAsTextFile(path)	将数据集的元素以textfile的形式保存到HDFS文件系统或者其他支持的文件系统，对于每个元素，Spark将会调用toString方法，将它装换为文件中的文本
saveAsSequenceFile(path)	将数据集中的元素以Hadoop sequencefile的格式保存到指定的目录下，可以使HDFS或者其他Hadoop支持的文件系统。
saveAsObjectFile(path)	将数据集的元素，以 Java 序列化的方式保存到指定的目录下
countByKey()	针对(K,V)类型的RDD，返回一个(K,Int)的map，表示每一个key对应的元素个数。
foreach(func)	在数据集的每一个元素上，运行函数func进行更新。
foreachPartition(func)	在数据集的每一个分区上，运行函数func

统计操作

算子	含义
count	个数
mean	均值
sum	求和
max	最大值
min	最小值
variance	方差
sampleVariance	从采样中计算方差
stdev	标准差:衡量数据的离散程度
sampleStdev	采样的标准差
stats	查看统计结果

RDD分区的数据取决的因素

RDD分区的原则是使得分区的个数尽量等于集群中的CPU核心(core)数目，这样可以充分利用CPU的计算资源,但是在实际中为了更加充分的压榨CPU的计算资源,会把并行度设置为cpu核数2~3倍。RDD分区数和启动时指定的核数、调用方法时指定的分区数、如文件本身分区数有关系

1.启动的时候指定的CPU核数确定了一个参数值:

spark.default.parallelism=指定的CPU核数(集群模式最小2)

2.对于Scala集合调用parallelize(集合,分区数)方法

如果没有指定分区数,就使用spark.default.parallelism,

如果指定了就使用指定的分区数(不要指定大于spark.default.parallelism)

3.对于textFile(文件,分区数)

如果没有指定分区数sc.defaultMinPartitions=min(defaultParallelism,2)

如果指定了就使用指定的分区数sc.defaultMinPartitions=指定的分区数

4.对于本地文件

rdd的分区数 = max(本地file的分片数， sc.defaultMinPartitions)

5.对于HDFS文件

rdd的分区数 = max(hdfs文件的block数目，sc.defaultMinPartitions)

所以如果分配的核数为多个，且从文件中读取数据创建RDD，即使hdfs文件只有1个切片，最后的Spark的RDD的partition数也有可能是2

常用API

创建RDD

val rdd1 = sc.parallelize(List(5,6,4,7,3,8,2,9,1,10))



//makeRDD方法底层调用了parallelize方法

val rdd2 = sc.makeRDD(List(5,6,4,7,3,8,2,9,1,10))

查看该RDD的分区数量

//没有指定分区数,默认值是2
sc.parallelize(List(5,6,4,7,3,8,2,9,1,10)).partitions.length

//指定了分区数为3
sc.parallelize(List(5,6,4,7,3,8,2,9,1,10),3).partitions.length

//没有指定分区数,默认值是2
sc.textFile("hdfs://node01:8020/words.txt").partitions.length

map

对RDD中的每一个元素进行操作并返回操作的结果

val rdd1 = sc.parallelize(List(5, 6, 4, 7, 3, 8, 2, 9, 1, 10)) 

//collect方法表示收集,是action操作
rdd1.map(_ * 2).collect

filter

函数中返回True的被留下,返回False的被过滤掉

val rdd2 = sc.parallelize(List(5, 6, 4, 7, 3, 8, 2, 9, 1, 10))
val rdd3 = rdd2.filter(_ >= 10)
rdd3.collect

flatmap

对RDD中的每一个元素进行先map再压扁,最后返回操作的结果

val rdd1 = sc.parallelize(Array("a b c", "d e f", "h i j"))

//将rdd1里面的每一个元素先切分再压平
val rdd2 = rdd1.flatMap(_.split(' '))
rdd2.collect

sortBy

排序

val rdd1 = sc.parallelize(List(5, 6, 4, 7, 3, 8, 2, 9, 1, 10))

// x=>x 表示按照元素本身进行排序,True表示升序
val rdd2 = rdd1.sortBy(x=>x,true) 
rdd2.collect

//x=>x+""表示按照x的字符串形式排序变成了字符串,结果为字典顺序
val rdd2 = rdd1.sortBy(x=>x+"",true)
rdd2.collect

并集（union）

val rdd1 = sc.parallelize(List(5, 6, 4, 3))
val rdd2 = sc.parallelize(List(1, 2, 3, 4))

//union不会去重 求并集
val rdd3 = rdd1.union(rdd2)
rdd3.collect

//去重
rdd3.distinct.collect

交集（intersection）

val rdd1 = sc.parallelize(List(5, 6, 4, 3))
val rdd2 = sc.parallelize(List(1, 2, 3, 4))

//求交集
val rdd4 = rdd1.intersection(rdd2)
rdd4.collect

差集（subtract）

val rdd1 = sc.parallelize(List(5, 6, 4, 3))
val rdd2 = sc.parallelize(List(1, 2, 3, 4))

//求差集
val rdd5 = rdd1.subtract(rdd2)
rdd5.collect

笛卡尔积（cartesian）

//学生
val rdd1 = sc.parallelize(List("jack", "tom"))

//课程
val rdd2 = sc.parallelize(List("java", "python", "scala"))

//笛卡尔积
//表示所有学生的所有选课情况
val rdd3 = rdd1.cartesian(rdd2)
rdd3.collect

join

join(内连接)聚合具有相同key组成的value元组

val rdd1 = sc.parallelize(List(("tom", 1), ("jerry", 2), ("kitty", 3)))
val rdd2 = sc.parallelize(List(("jerry", 9), ("tom", 8), ("shuke", 7), ("tom", 2)))


//聚合
val rdd3 = rdd1.join(rdd2)
rdd3.collect

leftOuterJoin

左外连接,左边的全留下,右边的满足条件的才留下

val rdd1 = sc.parallelize(List(("tom", 1), ("jerry", 2), ("kitty", 3)))
val rdd2 = sc.parallelize(List(("jerry", 9), ("tom", 8), ("shuke", 7), ("tom", 2)))

//左外连接
val rdd4 = rdd1.leftOuterJoin(rdd2)
rdd4.collect

rightOuterJoin

右外连接,右边的全留下,左边的满足条件的才留下

val rdd1 = sc.parallelize(List(("tom", 1), ("jerry", 2), ("kitty", 3)))
val rdd2 = sc.parallelize(List(("jerry", 9), ("tom", 8), ("shuke", 7), ("tom", 2)))

//右外连接
val rdd5 = rdd1.rightOuterJoin(rdd2)
rdd5.collect

groupbykey

对具有相同键的值进行分组

val rdd6 = sc.parallelize(Array(("tom",1), ("jerry",2), ("kitty",3), ("jerry",9), ("tom",8), ("shuke",7), ("tom",2)))
val rdd7=rdd6.groupByKey
rdd7.collect

cogroup

cogroup是先RDD内部分组,在RDD之间分组

val rdd1 = sc.parallelize(List(("tom", 1), ("tom", 2), ("jerry", 3), ("kitty", 2)))
val rdd2 = sc.parallelize(List(("jerry", 2), ("tom", 1), ("shuke", 2)))
val rdd3 = rdd1.cogroup(rdd2)
rdd3.collect

groupBy

根据指定的函数中的规则/key进行分组

val intRdd = sc.parallelize(List(1,2,3,4,5,6))
val result = intRdd.groupBy(x=>{if(x%2 == 0)"even" else "odd"})
result.collect

reduce

聚合

val rdd1 = sc.parallelize(List(1, 2, 3, 4, 5))

//reduce聚合 reduce是action
val result = rdd1.reduce(_ + _)

reducebykey

根据key，对相同key的元素进行操作

val rdd1 = sc.parallelize(List(("tom", 1), ("jerry", 3), ("kitty", 2),  ("shuke", 1)))
val rdd2 = sc.parallelize(List(("jerry", 2), ("tom", 3), ("shuke", 2), ("kitty", 5)))

//并集
val rdd3 = rdd1.union(rdd2) 
rdd3.collect

//按key进行聚合
val rdd4 = rdd3.reduceByKey(_ + _)
rdd4.collect

repartition

改变分区数

1.repartition可以增加和减少rdd中的分区数，

2.coalesce默认减少rdd分区数，增加rdd分区数不会生效。

3.不管增加还是减少分区数原rdd分区数不变,变的是新生成的rdd的分区数

//指定3个分区
val rdd1 = sc.parallelize(1 to 10,3)

//减少分区 新生成的rdd分区数为2
rdd1.repartition(2).partitions.length

//查看原来的分区 原来的rdd分区数不变
rdd1.partitions.length

//增加分区
rdd1.repartition(4).partitions.length

//减少分区
rdd1.coalesce(2).partitions.size

collect

在驱动程序中，以数组的形式返回数据集的所有元素

val rdd1 = sc.parallelize(List(6,1,2,3,4,5), 2)
rdd1.collect

count

count统计集合中元素的个数

val rdd1 = sc.parallelize(List(6,1,2,3,4,5), 2)
rdd1.count

distinct

去重

val rdd = sc.parallelize(Array(1,2,3,4,5,5,6,7,8,1,2,3,4), 3)
rdd.distinct.collect

top

取出最大的前N个

val rdd1 = sc.parallelize(List(3,6,1,2,4,5))
rdd1.top(2)

take

按照顺序取前N个

val rdd1 = sc.parallelize(List(3,6,1,2,4,5))

//3 6
rdd1.take(2) 

//需求:取出最小的2个
rdd1.sortBy(x=>x,true).take(2)

first

取第一个元素

val rdd1 = sc.parallelize(List(3,6,1,2,4,5))
rdd1.first

keys

获取所有key

val rdd1 = sc.parallelize(List("dog", "tiger", "lion", "cat", "panther", "eagle"), 2)
val rdd2 = rdd1.map(x => (x.length, x))
rdd2.collect

rdd2.keys.collect

values

获取所有value

val rdd1 = sc.parallelize(List("dog", "tiger", "lion", "cat", "panther", "eagle"), 2)
val rdd2 = rdd1.map(x => (x.length, x))
rdd2.collect

rdd2.values.collect

mapValues

mapValues表示对RDD中的元素进行操作,Key不变,Value变为操作之后

val rdd1 = sc.parallelize(List((1,10),(2,20),(3,30)))

//_表示每一个value ,key不变,将函数作用于value
val rdd2 = rdd1.mapValues(_*2).collect

collectAsMap

转换成Map

val rdd = sc.parallelize(List(("a", 1), ("b", 2)))
rdd.collectAsMap

没去过埃及的法老

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【SparkCore】RDD常用方法以及使用

目录创建RDD1.由外部存储系统的数据集创建，包括本地的文件系统，还有所有Hadoop支持的数据集，比如HDFS、Cassandra、HBase等2.通过已有的RDD经过算子转换生成新的RDD3.由一个已经存在的Scala集合创建RDD的方法/算子分类Transformation转换算子Action动作算子RDD分区的数据取决的因素常用API创建RDD查...
复制链接

扫一扫