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：

（2）action--动作类型

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

四、关于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，【搞定】一篇文章带你走出跨域险阻~