Spark-RDD简介以及算子实例

最新推荐文章于 2024-05-28 22:46:39 发布

JAVA和人工智能

最新推荐文章于 2024-05-28 22:46:39 发布

阅读量941

点赞数 1

分类专栏： spark 文章标签： spark RDD 算子

spark 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

Spark-RDD简介以及算子实例

一、RDD概述

1.1 什么是RDD？

RDD（Resilient Distribute Dataset）叫做分布式数据集。式Spark最基本的数据抽象。

它代表一个不可变，可分区，里面的元素可并行计算的集合。

RDD具有数据流模型的特点：自动容错、位置感应性调度和可伸缩性。

RDD运行多个用户在执行多个查询时显示的将工作集缓存在内存中，后续的查询能够重用工作集，极大的提升了查询速度。

1.2 RDD的属性

（1）一片分组（Partition）即数据集的基本组成单位。

对于RDD来说，每个分片都会被一个计算任务处理，并决定并行计算的粒度。

用户可以在创建RDD时指定RDD分片数目。如果没有指定，就会采用默认值。

默认值就是程序所分配到cpu core的数目。

（2）计算每个分区的函数

Spark中RDD的计算一分片为单位，每个RDD都会实现compute函数以达到这个目的。

compute函数会对迭代器进行复合。不需要保存每个计算的结果。

（3）RDD之间的依赖关系

RDD的每次转换都会生成一个新的RDD，所有RDD之间就会形成类似于流水线一样的前后依赖关系。在部分分区数据丢失时，Spark可以通过这个依赖关系重新计算丢失的分区数据，而不是对RDD所有分区进行计算。

（4）partitioner，RDD的分片函数

当前Spark中实现两种类型的分片函数。一个是基于hashPartitioner。

另外一个是基于范围的RangePartitioner。

只有对于Key-Value的RDD,才会有Partitioner,非key-value的RDD的Partitioner的值为none。

（5）一个列表，存储、存取每个partition的优先位置（preferred location）

对于一个Hdfs而言，这个列表保存的就是每个partition所在的块的位置。

按照“移动数据不如移动计算”的理论，Spark 在进行任务调度的时候，会尽可能的将计算任务分配到其所要处理数据块的存储位置。

二、两种生成RDD的方式

2.1 使用textFile方法，通过本地文件或HDFS创建RDD

val rdd01 = sc.textFile("hdfs://centos01:9000/ws")
rdd01.collect

2.2 并行化的生成RDD，调用SparkContext中的parallelize()方法

val arr = Array(1,2,3,4,5)
val rdd2 = sc.parallelize(arr)
rdd2.collect

三、RDD的两种类型

3.1 举例说明：

map是一个转换，它通过一个函数传递每个数据集元素，并返回一个表示结果的新RDD。另一方面，reduce是一个使用某个函数聚合RDD的所有元素并将最终结果返回给驱动程序的动作（尽管还有一个reduceByKey返回分布式数据集的并行）。

3.2 详细解说：

（1）transformation--转换类型

主要做得就是将一个已有的RDD生成另外一个RDD。transformation具有Lazy特性，transformation不会真正被执行。只有当我们的的程序遇到一个action算子的时候，代码才会被执行。这种设计让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])	先按分区聚合再总的聚合每次要跟初始值交流例如：aggregateByKey(0)(_+_,_+_) 对k/y的RDD进行操作
sortByKey([ascending], [numTasks])	在一个(K,V)的RDD上调用，K必须实现Ordered接口，返回一个按照key进行排序的(K,V)的RDD
sortBy(func,[ascending], [numTasks])	与sortByKey类似，但是更灵活第一个参数是根据什么排序第二个是怎么排序 false倒序第三个排序后分区数默认与原RDD一样
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)	两个RDD的笛卡尔积的成很多个K/V
pipe(command, [envVars])	调用外部程序
coalesce(numPartitions)	重新分区第一个参数是要分多少区，第二个参数是否shuffle 默认false 少分区变多分区 true 多分区变少分区 false
repartition(numPartitions)	重新分区必须shuffle 参数是要分多少区少变多
repartitionAndSortWithinPartitions(partitioner)	重新分区+排序比先分区再排序效率高对K/V的RDD进行操作
foldByKey(zeroValue)(seqOp)	该函数用于K/V做折叠，合并处理，与aggregate类似第一个括号的参数应用于每个V值第二括号函数是聚合例如：_+_
combineByKey	合并相同的key的值 rdd1.combineByKey(x => x, (a: Int, b: Int) => a + b, (m: Int, n: Int) => m + n)
partitionBy（partitioner）	对RDD进行分区 partitioner是分区器例如new HashPartition(2
cache	RDD缓存，可以避免重复计算从而减少时间，区别：cache内部调用了persist算子，cache默认就一个缓存级别MEMORY-ONLY ，而persist则可以选择缓存级别
persist

Subtract（rdd）	返回前rdd元素不在后rdd的rdd
leftOuterJoin	leftOuterJoin类似于SQL中的左外关联left outer join，返回结果以前面的RDD为主，关联不上的记录为空。只能用于两个RDD之间的关联，如果要多个RDD关联，多关联几次即可。
rightOuterJoin	rightOuterJoin类似于SQL中的有外关联right outer join，返回结果以参数中的RDD为主，关联不上的记录为空。只能用于两个RDD之间的关联，如果要多个RDD关联，多关联几次即可
subtractByKey	substractByKey和基本转换操作中的subtract类似只不过这里是针对K的，返回在主RDD中出现，并且不在otherRDD中出现的元素

（2）action--动作类型

可以出发代码的运行，而Spark的运行必须要有一个action类型操作。

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

四、关于RDD算子的小练习

已经将所有的题目要求并打印数据都包含在scala类当中了，可以直接进行拷贝，查看打印结果。

package day06

import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

class SparkRDDTest {

}

/**
  * Spark 内算子进行 练习。
  */
object SparkRDDTest{

  def main(args: Array[String]): Unit = {

    val conf: SparkConf = new SparkConf().setAppName("SparkRDDTest").setMaster("local")
    val context: SparkContext = new SparkContext(conf)

    /* 一、
    1,通过并行生成rdd1
    2,对rdd1的每一个元素*2进行排序
    3, 过滤》= 10 的元素
    4,将元素以数组的方式打印出来
    */
    val rdd1: RDD[Integer] = context.parallelize((List(1,3,5,7,9,0,2,4,6,8)))

    val res2: RDD[Int] = rdd1.map(_ * 2).sortBy(x => x,true)
    val res3: RDD[Int] = res2.filter(_ >=10)

    println("对RDD的每一个元素*2进行排序 :  "+res2.collect().toBuffer)
    println("过滤 >= 10 的元素 :  "+res3.collect().toBuffer)


    /* 二、
    1,通过并行生成rdd2
    2,对rdd2先切分，后压平。
    */
    val rdd2: RDD[String] = context.parallelize(Array("1 2 3","z x c","q,w,e"))

    val res4: RDD[String] = rdd2.flatMap(_.split(" "))

    println("对rdd2先切分，后压平 :  "+res4.collect().toBuffer)

    /* 三 、
    1,通过并行生成rdd3(稍微复杂一点)
    2,对rdd3先切分，后压平。
    */
    val rdd3: RDD[List[String]] = context.parallelize(List(List("q w e","a s d","t i o"),List("q w q","r s d","r i o"),List("q w e","a s d","t i o")))
    val res5: RDD[String] = rdd3.flatMap(_.flatMap(_.split(" ")))
    println("对res5先切分，后压平 :  "+res5.collect().toBuffer)

    /* 四、
    1,建立 rdd4 rdd5
    2,求并集 ，求交集 ，去重
    */
    val rdd4: RDD[Int] = context.parallelize(List(1,3,5))
    val rdd5: RDD[Int] = context.parallelize(List(2,4,5))

    val res6: RDD[Int] = rdd4 union rdd5
    val res7: RDD[Int] = rdd4 intersection(rdd5)
    val res8: RDD[Int] = res6 distinct() //先合并，后去重（直接调用方法即可）

    println("求并集 :  "+res6.collect().toBuffer)
    println("求交集 :  "+res7.collect().toBuffer)
    println("去重 :  "+res8.collect().toBuffer)

    /* 五、
     1,建立 rdd6 rdd7
     2,求join
     3,求左连接和右连接。
     4，求并集,进行分组
     5，分别用groupByKey和reduceByKey实现单词计数，注意groupByKey和reduceByKey的区别
     6,cogroup 进行统计
     7, 按Value降序排列
     8,笛卡尔积
     */
    val rdd6: RDD[(String, Int)] = context.parallelize(List(("tom1",1),("join1",4),("tom3",3)))
    val rdd7: RDD[(String, Int)] = context.parallelize(List(("join1",4),("tom1",5),("join3",6)))

    val res9: RDD[(String, (Int, Int))] = rdd6 join rdd7
    val res10: RDD[(String, (Int, Option[Int]))] = rdd6.leftOuterJoin(rdd7)
    val res11: RDD[(String, (Option[Int], Int))] = rdd6.rightOuterJoin(rdd7)
    val res12: RDD[(String, Iterable[Int])] = rdd6.union(rdd7).groupByKey()
    val res13: RDD[(String, Int)] = rdd6.union(rdd7).groupByKey().mapValues(_.sum)
    val res14: RDD[(String, Int)] = rdd6.union(rdd7).reduceByKey(_+_)
    val res15: RDD[(String, (Iterable[Int], Iterable[Int]))] = rdd6.cogroup(rdd7)
    val res16: RDD[(String, Int)] = res14.map(t =>(t._2,t._1)).sortByKey(false).map(t =>(t._2,t._1))
    val res18: RDD[((String, Int), (String, Int))] = rdd6.cartesian(rdd7)
    println("2,join  :  "+res9.collect().toBuffer)
    println("3,左连接  :  "+res10.collect().toBuffer)
    println("3,右连接  :  "+res11.collect().toBuffer)
    println("4,并集 进行分组 :  "+res12.collect().toBuffer)
    println("5,groupByKey  实现单词计数 :  "+res13.collect().toBuffer)
    println("5,reduceByKey 实现单词计数 :  "+res14.collect().toBuffer)
    println("6,cogroup 进行统计 :  "+res15.collect().toBuffer)
    println("7,按Value降序排列 :  "+res16.collect().toBuffer)
    println("7,笛卡尔积 :  "+res18.collect().toBuffer)

    /* 六、
     1,建立 rdd8
     2,reduce 聚合
     */
    val rdd8: RDD[Int] = context.parallelize(List(1,2,4,6,8,3))
    val res17: Int = rdd8.reduce(_+_)
    println("2,reduce 聚合 :  "+res17)
  }
}

欢迎订阅关注公众号（JAVA和人工智能）

获取更多免费书籍、资源、视频资料

文章超级链接：

1，分布式系统详解--基础知识（概论）

2，分布式系统详解--基础知识（线程）

3，IDEA和Eclipse的比较

4，IntelliJ IDEA（最新）安装-破解详解--亲测可用

5，scala-构造器-辅助构造器-伴生对象-单例对象

6，【由浅入深】爬虫技术，值得收藏，来了解一下~

7，Akka 简介及简单原理

8，Spark-集群安装、部署、启动、测试（1.6.3）稳定版

9，Scala +Spark+Hadoop+Zookeeper+IDEA实现WordCount单词计数（简单实例--上）

10，【搞定】一篇文章带你走出跨域险阻~

JAVA和人工智能

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
1
评论
Spark-RDD简介以及算子实例

Spark-RDD简介以及算子实例一、RDD概述1.1 什么是RDD？RDD（Resilient Distribute Dataset）叫做分布式数据集。式Spark最基本的数据抽象。它代表一个不可变，可分区，里面的元素可并行计算的集合。RDD具有数据流模型的特点：自动容错、位置感应性调度和可伸缩性。RDD运行多个...
复制链接

扫一扫