Spark RDD概念及常用算子创建过程

Spark RDD概念-1

简单的解释

RDD是将数据项拆分为多个分区的集合，存储在集群的工作节点上的内存中，并执行正确的操作

复杂的解释

1.RDD是用于数据转换的接口
2.RDD指向了存储在HDFS、Cassandra、HBase等、或缓存（内存、内存+磁盘、仅磁盘等），或在故障或缓存收回时重新计算其他RDD分区中的数据

Spark RDD概念-2

RDD是弹性分布式数据集（Resilient Distributed Datasets）

分布式数据集

1.RDD是只读的、分区记录的集合，每个分区分布在集群的不同节点上
2.RDD并不存储真正的数据，只是对数据和操作的描述

弹性

RDD默认存放在内存中，当内存不足，Spark自动将RDD写入磁盘

容错性

根据数据血统，可以自动从节点失败中恢复分区

RDD与DAG

两者是Spark提供的核心抽象

DAG（有向无环图）反映了RDD之间的依赖关系

RDD的特性

1.一系列的分区（分片）信息，每个任务处理一个分区
2.每个分区上都有compute函数，计算该分区中的数据
3.RDD之间有一系列的依赖
4.分区函数决定数据（key-value）分配至哪个分区
5.最佳位置列表，将计算任务分派到其所在处理数据块的存储位置

RDD编程流程

RDD分区

分区是RDD被拆分并发送到节点的不同块之一

1.我们拥有的分区越多，得到的并行性就越强
2.每个分区都是被分发到不同Worker Node的候选者
3.每个分区对应一个Task

RDD的操作

分为lazy与non-lazy两种

1.Transformation（lazy）：也称转换操作、转换算子
2.Actions（non-lazy）：立即执行，也称动作操作、动作算子

RDD转换算子

对于转换操作，RDD的所有转换都不会直接计算结果

1.仅记录作用于RDD上的操作
2.当遇到动作算子（Action）时才会进行真正计算

RDD的创建-1

打开IDEA

使用集合创建RDD

val rdd=sc.parallelize(List(1,2,3,4,5,6))
rdd.count
rdd.partitions.size
val rdd=sc.parallelize(List(1,2,3,4,5,6),5)
rdd.partitions.size
val rdd=sc.makeRDD(List(1,2,3,4,5,6))
//注意：1、Spark默认会根据集群的情况来设置分区的数量，也可以通过parallelize()第二参数来指定
//2、Spark会为每一个分区运行一个任务进行处理

RDD常用算子实例

object RDDDemo {
  def main(args: Array[String]): Unit = {
    val conf=new SparkConf().setMaster("local[3]").setAppName("rdddemo")
    val sc=new SparkContext(conf)

    val rdd1=sc.parallelize(List(1,2,3,4,5,6,7,8,9,9,2,6))
    val rdd2=rdd1.distinct
    //println("rdd1分区数："+rdd1.partitions.length)

    //rdd2.collect.foreach(println)
   // println("rdd2分区数："+rdd2.partitions.length)

    val rdd3 = rdd1.distinct(2)
   // println("rdd3分区数："+rdd3.partitions.length)

    val u1=sc.parallelize(1 to 3)
    val u2=sc.parallelize(3 to 4)

    u1.union(u2).collect.foreach(println)
    println("------------------------------")

    (u1++u2).collect.foreach(println)
    println("------------------------------")

    u1.intersection(u2).collect.foreach(println)
    println("------------------------------")

    val j1=sc.parallelize(List("abe","abby","apple")).map(a=>(a,1))
    val j2=sc.parallelize(List("apple","beatty","beatrice")).map(a=>(a,1))

    j1.join(j2).collect.foreach(println)
    println("------------------------------")

    j1.leftOuterJoin(j2).collect.foreach(println)
    println("------------------------------")

    j1.rightOuterJoin(j2).collect.foreach(println)
  }
}

map算子

object MapDemo {
  def main(args: Array[String]): Unit = {
    val conf=new SparkConf().setMaster("local[2]").setAppName("mapdemo")
    val sc=new SparkContext(conf)
    val rdd1=sc.makeRDD(1 to 9,3)
    val rdd2=rdd1.map(_*2)
    rdd2.collect.foreach(println)

    println("-------------------------------------------")
    val strRdd1=sc.parallelize(List("kb02","kb05","kb07","kb09","spark","study"))
    val strRdd2=strRdd1.map(x=>(x,1))
    strRdd2.collect.foreach(println)

    println("---------------------------------------------")
    val filterRdd1=sc.makeRDD(List(1,2,3,4,5,6,7,8,9,10),3)
    val filterRdd2 = filterRdd1.filter(_%2==0)
    filterRdd2.collect.foreach(println)

    println("----------------------------------------------")
    val mapValuesRdd1 = sc.parallelize(List("tiger","dog","cat","lion","eagle","panther"))
    val mapValuesRdd2 = mapValuesRdd1.map(x=>(x.length,x))
    mapValuesRdd2.collect.foreach(println)
//    val mapValuesRdd3=mapPairesRdd2.mapValues(x=>"_"+x+"_")
//    mapValuesRdd3.collect.foreach(println)
    println("-----------------reduceByKey--------------")
    val reduceByKeyRdd1 = mapValuesRdd2.reduceByKey((a,b)=>a+b)
    reduceByKeyRdd1.collect.foreach(println)

    println("------------------groupByKey-------------")
    val groupByKeyRdd=mapValuesRdd2.groupByKey()
    groupByKeyRdd.collect.foreach(println)

    println("-----------------sortBYKeyRdd---------------")
    val sortByKeyRdd=mapValuesRdd2.sortByKey(false)
    sortByKeyRdd.collect.foreach(println)

  }
}

reduce(binary_function)
reduce将RDD中元素前两个传给输入函数，产生一个新的return值，新产生的return值与RDD中下一个元素（第三个元素）组成两个元素，再被传给输入函数，直到最后只有一个值为止。

val c = sc.parallelize(1 to 10)
c.reduce((x, y) => x + y)//结果55

具体过程，RDD有1 2 3 4 5 6 7 8 9 10个元素，

1+2=3 
3+3=6 
6+4=10 
10+5=15 
15+6=21 
21+7=28 
28+8=36 
36+9=45 
45+10=55

reduceByKey(binary_function)
reduceByKey就是对元素为KV对的RDD中Key相同的元素的Value进行binary_function的reduce操作，因此，Key相同的多个元素的值被reduce为一个值，然后与原RDD中的Key组成一个新的KV对。

val a = sc.parallelize(List((1,2),(1,3),(3,4),(3,6)))
a.reduceByKey((x,y) => x + y).collect
1
2
//结果 Array((1,5), (3,10))

RDD的创建-2

通过加载文件产生RDD

val distFile=sc.textFile("file:///home/hadoop/data/hello.txt")
distFile.count
val distHDFSFile=sc.textFile("hdfs://hadoop001:9000/hello.txt")

加载“file://……”时，以local运行仅需一份本地文件，以Spark集群方式运行，应保证每个节点均有该文件的本地副本

object ActionRddDemo {
  def main(args: Array[String]): Unit = {
    val conf=new SparkConf().setMaster("local[1]").setAppName("actionrdddemo")
    val sc = new SparkContext(conf)
    val rdd1=sc.parallelize(1 to 100)
    val sum=rdd1.reduce((x,y)=>{println(x,y);x+y})
    println("总和："+sum)


    //rdd1.saveAsTextFile("in/rdd1.txt")
    rdd1.saveAsTextFile("hdfs://hadoop001:9000/kb09workspace/rdd1demodata")

  }
}

RDD动作算子

1.本质上动作算子通过SparkContext执行提交作业操作，触发RDD DAG（有向无环图）的执行
2.所有的动作算子都是急迫型（non-lazy），RDD遇到Action就会立即计算

RDD常用动作算子

count

返回的是数据集中的元素的个数

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

collect

以Array返回RDD的所有元素。一般在过滤或者处理足够小的结果的时候使用

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

take

返回前n个元素

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

first

返回RDD第一个元素

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

reduce

根据指定函数，对RDD中的元素进行两两计算，返回计算结果

val a=sc.parallelize(1 to 100)
a.reduce((x,y)=>x+y)
a.reduce(_+_)		//与上面等价
val b=sc.parallelize(Array(("A",0), ("A",2), ("B",1), ("B",2), ("C",1)))
b.reduce((x,y)=>{(x._1+y._1,x._2+y._2)})		//(AABBC,6)

foreach

对RDD中的每个元素都使用指定函数，无返回值

val rdd=sc.parallelize(1 to 100)
rdd.foreach(println)

lookup

用于PairRDD,返回K对应的所有V值

val rdd=sc.parallelize(List(('a',1), ('a',2), ('b',3), ('c',4)))
rdd.lookup('a')		//输出WrappedArray(1, 2)

最值

返回最大值、最小值

val y=sc.parallelize(10 to 30)
y.max	//求最大值
y.min	//求最小值

saveAsTextFile

保存RDD数据至文件系统

val rdd=sc.parallelize(1 to 10,2)
rdd.saveAsTextFile("hdfs://hadoop000:8020/data/rddsave/")