Spark-RDD编程

Spark-RDD编程

1.1 RDD概述

1.11定义

​ RDD（Resilient DistributedDataset）叫做分布式数据集，是Spark中最基本的数据抽象。代码中是一个抽象类，它代表一个不可变、可分区、里面的元素可并行计算的集合。

1.12 属性

1. 一组分区（Partition），即数据集的基本组成单位;
   

2. 一个计算每个分区的函数;
   

3. RDD之间的依赖关系;
   

4. 一个Partitioner，即RDD的分片函数;
   

5. 一个列表，存储存取每个Partition的优先位置（preferred location）。
   

1.13特点

​ RDD表示只读的分区的数据集，对RDD进行改动，只能通过RDD的转换操作，由一个RDD得到一个新的RDD，新的RDD包含了从其他RDD衍生所必需的信息。RDDs之间存在依赖，RDD的执行是按照血缘关系延时计算的。如果血缘关系较长，可以通过持久化RDD来切断血缘关系。

1.13.1 分区

​ RDD逻辑上是分区的，每个分区的数据是抽象存在的，计算的时候会通过一个compute函数得到每个分区的数据。如果RDD是通过已有的文件系统构建，则compute函数是读取指定文件系统中的数据，如果RDD是通过其他RDD转换而来，则compute函数是执行转换逻辑将其他RDD的数据进行转换。

1.13.2 只读

​ RDD是只读的，要想改变RDD中的数据，只能在现有的RDD基础上创建新的RDD。

​ 由一个RDD转换到另一个RDD，可以通过丰富的操作算子实现，不再像MapReduce那样只能写map和reduce了

RDD的操作算子包括两类，一类叫做transformations，它是用来将RDD进行转化，构建RDD的血缘关系；另一类叫做actions，它是用来触发RDD的计算，得到RDD的相关计算结果或者将RDD保存的文件系统中。下图是RDD所支持的操作算子列表。

1.13.3 依赖

​ RDDs通过操作算子进行转换，转换得到的新RDD包含了从其他RDDs衍生所必需的信息，RDDs之间维护着这种血缘关系，也称之为依赖。如下图所示，依赖包括两种，一种是窄依赖，RDDs之间分区是一一对应的，另一种是宽依赖，下游RDD的每个分区与上游RDD(也称之为父RDD)的每个分区都有关，是多对多的关系。

1.13.4 缓存

​ 如果在应用程序中多次使用同一个RDD，可以将该RDD缓存起来，该RDD只有在第一次计算的时候会根据血缘关系得到分区的数据，在后续其他地方用到该RDD的时候，会直接从缓存处取而不用再根据血缘关系计算，这样就加速后期的重用。如下图所示，RDD-1经过一系列的转换后得到RDD-n并保存到hdfs，RDD-1在这一过程中会有个中间结果，如果将其缓存到内存，那么在随后的RDD-1转换到RDD-m这一过程中，就不会计算其之前的RDD-0了。

1.13.5 CheckPoint

​ 虽然RDD的血缘关系天然地可以实现容错，当RDD的某个分区数据失败或丢失，可以通过血缘关系重建。但是对于长时间迭代型应用来说，随着迭代的进行，RDDs之间的血缘关系会越来越长，一旦在后续迭代过程中出错，则需要通过非常长的血缘关系去重建，势必影响性能。为此，RDD支持checkpoint将数据保存到持久化的存储中，这样就可以切断之前的血缘关系，因为checkpoint后的RDD不需要知道它的父RDDs了，它可以从checkpoint处拿到数据。

1.2 RDD模型

在Spark中，RDD被表示为对象，通过对象上的方法调用来对RDD进行转换。经过一系列的transformations定义RDD之后，就可以调用actions触发RDD的计算，action可以是向应用程序返回结果(count, collect等)，或者是向存储系统保存数据(saveAsTextFile等)。在Spark中，只有遇到action，才会执行RDD的计算(即延迟计算)，这样在运行时可以通过管道的方式传输多个转换。

​ 要使用Spark，开发者需要编写一个Driver程序，它被提交到集群以调度运行Worker，如下图所示。Driver中定义了一个或多个RDD，并调用RDD上的action，Worker则执行RDD分区计算任务。

1.3 RDD的创建

三种方式

1. 在集合中创建
2. 在外部存储中创建
3. 在其他的RDD中创建

1.3.1 集合中创建

Spark提供了两种函数: parallelize和 makeRDD

1. 使用parallelize()从集合中创建

   scala> val rdd = sc.parallelize(Array(1,2,3,4,5,6,7,8))
   rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[0] at parallelize at <console>:24
   
   

2. 使用makeRDD() 创建

   scala> val rdd1 = sc.makeRDD(Array(1 to 10))
   rdd1: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[1] at makeRDD at <console>:24
   
   

1.32 由外部系统创建RDD

包括了本地文件系统,还有所有的Hadoop支持的数据集,如 HDFS , Cassandra , HBase 等.

scala> val rdd2= sc.textFile("hdfs://hadoop100:9000/RELEASE")
rdd2: org.apache.spark.rdd.RDD[String] = hdfs:// hadoop100:9000/RELEASE MapPartitionsRDD[4] at textFile at <console>:24

1.33 从其他创建RDD

​ 请看下文

1.4 RDD的转换 (开发重点)

RDD整体上分为Value类型 和 Key-Value 类型

1.41 Value类型

1.41.1 map(func) 案例

1. 作用：返回一个新的RDD，该RDD由每一个输入元素经过func函数转换后组成

2. 需求：创建一个1-10数组的RDD，将所有元素*2形成新的RDD

scala> val rdd = sc.makeRDD(1 to 10)
rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[2] at makeRDD at <console>:24

scala> rdd.collect
res1: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> rdd.map(_ *2)
res2: org.apache.spark.rdd.RDD[Int] = MapPartitionsRDD[3] at map at <console>:27

scala> res2.collect
res3: Array[Int] = Array(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)

1.41.2 mapPartitions(func)案例

1. 作用：类似于map，但独立地在RDD的每一个分片上运行，因此在类型为T的RDD上运行时，func的函数类型必须是Iterator[T] => Iterator[U]。假设有N个元素，有M个分区，那么map的函数的将被调用N次,而mapPartitions被调用M次,一个函数一次处理所有分区。

2. 需求：创建一个RDD，使每个元素*2组成新的RDD

scala> val rdd = sc.makeRDD(1 to 5)
rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[0] at makeRDD at <console>:24

scala> rdd.mapPartitions(x=>x.map(_*2)).collect
res0: Array[Int] = Array(2, 4, 6, 8, 10)

1.41.3 mapPartitionsWithIndex(func) 案例

1. 作用：类似于mapPartitions，但func带有一个整数参数表示分片的索引值，因此在类型为T的RDD上运行时，func的函数类型必须是(Int, Interator[T]) => Iterator[U]；

2. 需求：创建一个RDD，使每个元素跟所在分区形成一个元组组成一个新的RDD

scala> rdd.mapPartitionsWithIndex((index,items)=>(items.map((index,_))))
res1: org.apache.spark.rdd.RDD[(Int, Int)] = MapPartitionsRDD[1] at mapPartitionsWithIndex at <console>:27

scala> res1.collect
res3: Array[(Int, Int)] = Array((0,1), (1,2), (2,3), (3,4), (3,5))

1.41.4 map()和mapPartition()的区别

1. map()：每次处理一条数据。

2. mapPartition()：每次处理一个分区的数据，这个分区的数据处理完后，原RDD中分区的数据才能释放，可能导致OOM。

3. 开发指导：当内存空间较大的时候建议使用mapPartition()，以提高处理效率。

1.41.5 flatMap(func) 案例

1. 作用：类似于map，但是每一个输入元素可以被映射为0或多个输出元素（所以func应该返回一个序列，而不是单一元素）

2. 需求：1->1 ; 2->1,2 ; 3->1,2,3 …

scala> val rdd = sc.makeRDD(1 to 5)
rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[0] at makeRDD at <console>:24

scala> rdd.flatMap(1 to _)
res0: org.apache.spark.rdd.RDD[Int] = MapPartitionsRDD[1] at flatMap at <console>:27

scala> res0.collect
res1: Array[Int] = Array(1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 2, 3, 4, 5)   

1.41.6 glom 案例

1. 作用：将每一个分区形成一个数组，形成新的RDD类型时RDD[Array[T]]

2. 需求：创建一个4个分区的RDD，并将每个分区的数据放到一个数组

scala> val rdd1 = sc.makeRDD(1 to 16,4)
rdd1: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[2] at makeRDD at <console>:24

scala> rdd1.glom().collect
res2: Array[Array[Int]] = Array(Array(1, 2, 3, 4), Array(5, 6, 7, 8), Array(9, 10, 11, 12), Array(13, 14, 15, 16))

1.41.7 groupBy(func)案例

1. 作用：分组，按照传入函数的返回值进行分组。将相同的key对应的值放入一个迭代器。

2. 需求：创建一个RDD，按照元素模以2的值进行分组。

scala> rdd1.groupBy(_%2).collect
res3: Array[(Int, Iterable[Int])] = Array((0,CompactBuffer(2, 4, 6, 8, 10, 12, 14, 16)), (1,CompactBuffer(1, 3, 5, 7, 9, 11, 13, 15)))

0表示true,1表示false,结果都会显示

1.41.8 filter(func) 案例

1. 作用：过滤。返回一个新的RDD，该RDD由经过func函数计算后返回值为true的输入元素组成。

2. 需求：创建一个RDD（由字符串组成），过滤出一个新RDD（包含”b”子串）

scala> val rdd2 = sc.makeRDD(Array("abc","acd","bcd","abcd"))
rdd2: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[4] at makeRDD at <console>:24

scala> rdd2.collect
res4: Array[String] = Array(abc, acd, bcd, abcd)

scala> rdd2.filter(_.contains("b")).collect
res5: Array[String] = Array(abc, bcd, abcd)

1.41.8 sample (withReplacement,fraction,seed) 案例

1. 以指定的随机种子随机抽样出数量为fraction的数据,withReplacement 表示是抽出的数据是否放回, true 为有放回的抽样,false为无放回的抽样,seed用于指定随机数生成器的种子.
2. 需求: 创建一个RDD,从中选择放回和不放回的抽样

scala> rdd1.collect
res6: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16)
//true 表示放回的抽样
scala> rdd1.sample(true,0.4,2).collect
res8: Array[Int] = Array(1, 2, 2, 10, 10, 11, 12, 13, 14)
//不放回抽样
scala> rdd1.sample(false,0.4,2).collect
res9: Array[Int] = Array(1, 3, 10, 12, 13, 16)

说明;

0.4 为一个系数,每次根据seed的值不同,产生的系数也不同,只有系数大于0.4时才抽样,所以,一般的种子都是随时间的不确定的值,避免随机数产生规律 (种子固定,算法固定的情况下)

1.41.9 distinct([numTasks])) 案例

1. 作用：对源RDD进行去重后返回一个新的RDD。默认情况下，只有8个并行任务来操作，但是可以传入一个可选的numTasks参数改变它。

2. 需求：创建一个RDD，使用distinct()对其去重。

scala> val distintRdd  = sc.parallelize(List(1,2,1,4,4,6,5))
distintRdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[8] at parallelize at <console>:24

scala> distintRdd.distinct().collect
res10: Array[Int] = Array(4, 1, 5, 6, 2)

//对RDD(指定并行读为2)
scala> distintRdd.distinct(2).collect
res11: Array[Int] = Array(4, 6, 2, 1, 5)

注意

1. distinct参数是可以改变的,并且去重的过程中还经历一次shuffle,所以去重后的数组是 无序的 .

1.41.10 coalesce(numPartitions)案例

1. 作用：根据分区数，重新通过网络随机洗牌所有数据。

2. 需求：创建一个4个分区的RDD，对其重新分区

scala> res18.glom.collect
res19: Array[Array[Int]] = Array(Array(1, 2, 3, 4), Array(5, 6, 7, 8), Array(9, 10, 11, 12, 13, 14, 15, 16))
//没有打乱顺序,仅仅是把最后两个结合起来了

1.41.11 repartition (numPartitions)案例

1. 作用：根据分区数，重新通过网络随机洗牌所有数据。

2. 需求：创建一个4个分区的RDD，对其重新分区

scala> rdd1.repartition(2).glom.collect
res20: Array[Array[Int]] = Array(Array(1, 3, 5, 7, 9, 11, 13, 15), Array(2, 4, 6, 8, 10, 12, 14, 16))
//打乱顺序重组

1.41.12 repartition和coalesce的区别

1. coalesce重新分区，可以选择是否进行shuffle过程。由参数shuffle: Boolean = false/true决定。

2. repartition实际上是调用的coalesce，默认是进行shuffle的。源码如下：

def repartition(numPartitions: Int)(implicit ord: Ordering[T] = null): RDD[T] = withScope {
   coalesce(numPartitions, shuffle = true)
 }

1.41.13 sortBy(func,[ascending],[numTasks])案例

1. 作用；使用func先对数据进行处理，按照处理后的数据比较结果排序，默认为正序。
2. 需求：创建一个RDD，按照不同的规则进行排序

//升序
scala> rdd.sortBy(x=>x).collect
res25: Array[Int] = Array(1, 2, 3, 4, 5, 8)
//降序
scala> rdd.sortBy(x=>x,false,2).collect
res30: Array[Int] = Array(8, 5, 4, 3, 2, 1)
//以3的余数排序
scala>  rdd.sortBy(x => x%3).collect()
res31: Array[Int] = Array(3, 1, 4, 2, 8, 5)

1.41.14 pipe(command,[envVars]) 案例

1. 作用：管道，针对每个分区，都执行一个shell脚本，返回输出的RDD。注意：脚本需要放在Worker节点可以访问到的位置

2. 需求：编写一个脚本，使用管道将脚本作用于RDD上。

编写一个脚本
Shell脚本
#!/bin/sh
echo "AA"
while read LINE; do
   echo ">>>"${LINE}
done

scala> val rdd = sc.makeRDD(List("hi","hello","world","lover"))
rdd: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[0] at makeRDD at <console>:24

scala> rdd.pipe("/opt/module/datas/spark/pipe.sh").collect
res0: Array[String] = Array(AA, >>>hi, AA, >>>hello, AA, >>>world, AA, >>>lover)

//创建一个有两个分区的RDD
scala> val rdd1 = sc.makeRDD(List("hi","hello","world","lover"),2)
rdd1: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[2] at makeRDD at <console>:24

scala> rdd1.pipe("/opt/module/datas/spark/pipe.sh").glom.collect
res2: Array[Array[String]] = Array(Array(AA, >>>hi, >>>hello), Array(AA, >>>world, >>>lover))

1.42 双Value类型交互

1.42.1 union (otherDateset) 案例

1. 作用: 对原RDD 和参数RDD求并集后返回一个新的RDD

2. 需求: 创建两个RDD,求并集

   //并集
   scala> rdd.union(rdd1).collect
   res5: Array[String] = Array(hi, hello, world, lover, hi, hello, world, lover)
   //分区的并集
   scala> rdd.union(rdd1).glom.collect
   res6: Array[Array[String]] = Array(Array(hi), Array(hello), Array(world), Array(lover), Array(hi, hello), Array(world, lover))
   

1.42.2 subtract (otherDataset) 案例

1. 作用：计算差的一种函数，去除两个RDD中相同的元素，不同的RDD将保留下来

2. 需求：创建两个RDD，求第一个RDD与第二个RDD的差集

scala> val rdd3 = sc.makeRDD(3 to 7)
rdd3: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[10] at makeRDD at <console>:24

scala> rdd3.collect
res7: Array[Int] = Array(3, 4, 5, 6, 7)

scala> val rdd4 = sc.makeRDD(2 to 5)
rdd4: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[11] at makeRDD at <console>:24

scala> rdd3.subtract(rdd4).collect
res8: Array[Int] = Array(6, 7)

1.42.3 intersection(otherDataset) 案例

1. 作用：对源RDD和参数RDD求交集后返回一个新的RDD

2. 需求：创建两个RDD，求两个RDD的交集

   scala> val rdd3 = sc.makeRDD(3 to 7)
   
   scala> val rdd4 = sc.makeRDD(2 to 5)
   
   scala> rdd3.intersection(rdd4).collect
   res9: Array[Int] = Array(4, 5, 3)
   
   //都是通过一次shuffle 无序
   

1.42.4 cartesian(otherDataset) 案例

1. 作用：笛卡尔积（尽量避免使用）

2. 需求：创建两个RDD，计算两个RDD的笛卡尔积

（1）创建第一个RDD

 scala> val rdd1 = sc.parallelize(1 to 3)
rdd1: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[47] at parallelize at <console>:24

（2）创建第二个RDD

scala> val rdd2 = sc.parallelize(2 to 5)

rdd2: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[48] at parallelize at <console>:24

（3）计算两个RDD的笛卡尔积并打印

scala> rdd1.cartesian(rdd2).collect()

res17: Array[(Int, Int)] = Array((1,2), (1,3), (1,4), (1,5), (2,2), (2,3), (2,4), (2,5), (3,2), (3,3), (3,4), (3,5))

1.42.5 zip(otherDataset) 案例

1. 作用：将两个RDD组合成Key/Value形式的RDD,这里默认两个RDD的partition数量以及元素数量都相同，否则会抛出异常。

2. 需求：创建两个RDD，并将两个RDD组合到一起形成一个(k,v)RDD

   scala> val rdd = sc.parallelize(1 to 3,3)
   rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[22] at parallelize at <console>:24
   
   scala> val rdd1 = sc.makeRDD(Array("a","b","c"),3)
   rdd1: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[23] at makeRDD at <console>:24
   
   scala> rdd.zip(rdd1).collect
   res10: Array[(Int, String)] = Array((1,a), (2,b), (3,c))
   
   

1.43 Key-Value 类型

1.43.1 partitionBy 案例

1. 作用：对pairRDD进行分区操作，如果原有的partionRDD和现有的partionRDD是一致的话就不进行分区， 否则会生成ShuffleRDD，即会产生shuffle过程。

2. 需求：创建一个4个分区的RDD，对其重新分区

scala> val rdd = sc.makeRDD(Array((1,"aaa"),(2,"bbb"),(3,"ccc"),(4,"ddd")),4)
rdd: org.apache.spark.rdd.RDD[(Int, String)] = ParallelCollectionRDD[0] at makeRDD at <console>:24

scala> rdd.partitions.size
res0: Int = 4

scala> val rdd1 = rdd.partitionBy(new org.apache.spark.HashPartitioner(2))
rdd1: org.apache.spark.rdd.RDD[(Int, String)] = ShuffledRDD[2] at partitionBy at <console>:26

scala> rdd1.partitions.size
res3: Int = 2

1.43.2 groupByKey案例

1. 作用：groupByKey也是对每个key进行操作，但只生成一个sequence。

2. 需求：创建一个pairRDD，将相同key对应值聚合到一个sequence中，并计算相同key对应值的相加结果。

scala> val words = Array("one","two","two","three","three","three")
words: Array[String] = Array(one, two, two, three, three, three)

scala> val wordMap = sc.makeRDD(words).map(word=> (word,1))
wordMap: org.apache.spark.rdd.RDD[(String, Int)] = MapPartitionsRDD[6] at map at <console>:26
//把相同key的值聚合到同一个队列中
scala> wordMap.groupByKey().collect
res6: Array[(String, Iterable[Int])] = Array((two,CompactBuffer(1, 1)), (one,CompactBuffer(1)), (three,CompactBuffer(1, 1, 1)))
//把key相对应的值相加
scala> wordMap.groupByKey().map(t =>(t._1,t._2.sum)).collect
res7: Array[(String, Int)] = Array((two,2), (one,1), (three,3))

1.43.3 reduceByKey (func,[numTasks]) 案例

1. 在一个(K,V)的RDD上调用，返回一个(K,V)的RDD，使用指定的reduce函数，将相同key的值聚合到一起，reduce任务的个数可以通过第二个可选的参数来设置。

2. 需求：创建一个pairRDD，计算相同key对应值的相加结果

scala> val rdd = sc.parallelize(List(("female",1),("male",5),("female",5),("male",2)))
rdd: org.apache.spark.rdd.RDD[(String, Int)] = ParallelCollectionRDD[10] at parallelize at <console>:24

scala> rdd.collect
res8: Array[(String, Int)] = Array((female,1), (male,5), (female,5), (male,2))
//key相等的值相加  和scala中的reduce相似
scala> rdd.reduceByKey((x,y)=>x+y).collect
res9: Array[(String, Int)] = Array((female,6), (male,7))

1.43.4 reduceByKey和groupByKey的区别

1. reduceByKey：按照key进行聚合，在shuffle之前有combine（预聚合）操作，返回结果是RDD[k,v].

2. groupByKey：按照key进行分组，直接进行shuffle。

3. 建议：reduceByKey比groupByKey，建议使用。但是需要注意是否会影响业务逻辑

1.43.5 aggregateByKey案例

参数：(zeroValue:U,[partitioner: Partitioner]) (seqOp: (U, V) => U,combOp: (U, U) => U)

1. 作用：在kv对的RDD中，，按key将value进行分组合并，合并时，将每个value和初始值作为seq函数的参数，进行计算，返回的结果作为一个新的kv对，然后再将结果按照key进行合并，最后将每个分组的value传递给combine函数进行计算（先将前两个value进行计算，将返回结果和下一个value传给combine函数，以此类推），将key与计算结果作为一个新的kv对输出。

2. 参数描述：

（1）zeroValue：给每一个分区中的每一个key一个初始值；

（2）seqOp：函数用于在每一个分区中用初始值逐步迭代value；

（3）combOp：函数用于合并每个分区中的结果。

3. 需求：创建一个pairRDD，取出每个分区相同key对应值的最大值，然后相加

4. 需求分析

过程叙述:

1. 每个区内把初始值和第一个值叠加,

2. 进行分区内比较, 选出每个区内的最大值, 分区1: a:3, c:4 分区2: b:3 c: 8

3. 分区内比较完后,进行分区直接相同的key叠加 ===> a: 3, b:3 ,c :12

4. 由于需要shuffle处理, 所以是无序的

scala>  val rdd = sc.parallelize(List(("a",3),("a",2),("c",4),("b",3),("c",6),("c",8)),2)
rdd: org.apache.spark.rdd.RDD[(String, Int)] = ParallelCollectionRDD[12] at parallelize at <console>:24

scala> rdd.aggregate
aggregate   aggregateByKey
//先进行区内排序,后进行区间相加
scala> rdd.aggregateByKey(0)(math.max(_,_),_+_).collect
res10: Array[(String, Int)] = Array((b,3), (a,3), (c,12))

1.43.6 foldByKey案例

参数：(zeroValue: V)(func: (V, V) => V): RDD[(K, V)]

1. 作用：aggregateByKey的简化操作，seqop和combop相同

2. 需求：创建一个pairRDD，计算相同key对应值的相加结果

scala> val rdd = sc.parallelize(List((1,3),(1,2),(1,4),(2,3),(3,6),(3,8)),3)
rdd: org.apache.spark.rdd.RDD[(Int, Int)] = ParallelCollectionRDD[14] at parallelize at <console>:24
// 与scala中的fold相似
scala> rdd.foldByKey(0)(_+_).collect
res11: Array[(Int, Int)] = Array((3,14), (1,9), (2,3))

1.43.7 combineByKey[C] 案例

参数：(createCombiner: V => C, mergeValue: (C, V) => C, mergeCombiners: (C, C) => C)

1. 作用：对相同K，把V合并成一个集合。

2. 参数描述：

（1）createCombiner: combineByKey()会遍历分区中的所有元素，因此每个元素的键要么还没有遇到过，要么就和之前的某个元素的键相同。如果这是一个新的元素,combineByKey()会使用一个叫作createCombiner()的函数来创建那个键对应的累加器的初始值

（2）mergeValue: 如果这是一个在处理当前分区之前已经遇到的键，它会使用mergeValue()方法将该键的累加器对应的当前值与这个新的值进行合并

（3）mergeCombiners: 由于每个分区都是独立处理的， 因此对于同一个键可以有多个累加器。如果有两个或者更多的分区都有对应同一个键的累加器， 就需要使用用户提供的 mergeCombiners() 方法将各个分区的结果进行合并。

3. 需求：创建一个pairRDD，根据key计算每种key的均值。（先计算每个key出现的次数以及可以对应值的总和，再相除得到结果）

4. 需求分析：

过程叙述:

1. 先把key对应的值映射为元组(88,1)…
2. 元组的第一位与value相加, 第二位自增1 ,
3. 元组的第一位与第二位分别累加

scala> val rdd = sc.parallelize(Array(("a", 88), ("b", 95), ("a", 91), ("b", 93), ("a", 95), ("b", 98)),2)
rdd: org.apache.spark.rdd.RDD[(String, Int)] = ParallelCollectionRDD[0] at parallelize at <console>:24

scala> val rdd1 = rdd.combineByKey((_,1),(acc:(Int,Int),v)=>(acc._1+v,acc._2+1),(acc1:(Int,Int),acc2:(Int,Int))=>(acc1._1+acc2._1,acc1._2+acc2._2))
rdd1: org.apache.spark.rdd.RDD[(String, (Int, Int))] = ShuffledRDD[2] at combineByKey at <console>:26

scala> rdd1.collect
res2: Array[(String, (Int, Int))] = Array((b,(286,3)), (a,(274,3)))             

//求和
scala>  val result = rdd1.map{case (key,value) => (key,value._1/value._2.toDouble)}
result: org.apache.spark.rdd.RDD[(String, Double)] = MapPartitionsRDD[3] at map at <console>:28      

scala> result.collect
res3: Array[(String, Double)] = Array((b,95.33333333333333), (a,91.33333333333333))

1.43.8 sortByKey([ascending],[numTasks]) 案例

1. 作用: 在一个(k,v) 的RDD上调用,k 必须实现Ordered接口,返回一个案子key进行排序的(k,v)的RDD.

2. 需求: 创建一个 pairRDD , 按照key 的正序和倒序进行排序

   scala> val rdd = sc.makeRDD(Array((2,"a"),(4,"b"),(1,"c")))
   rdd: org.apache.spark.rdd.RDD[(Int, String)] = ParallelCollectionRDD[0] at makeRDD at <console>:24
   //true表示升序
   scala> rdd.sortByKey(true).collect
   res0: Array[(Int, String)] = Array((1,c), (2,a), (4,b))                         
   //false表示逆序
   scala> rdd.sortByKey(false).collect
   res1: Array[(Int, String)] = Array((4,b), (2,a), (1,c))
   
   

1.43.9 mapValues 案例

1. 针对于 (k,v) 形式的类型只针对 v 进行操作

2. 需求: 创建一个 pairRDD ,并将 value 添加字符串"|||"

   scala> val rdd = sc.makeRDD(Array((2,"a"),(4,"b"),(1,"c")))
   rdd: org.apache.spark.rdd.RDD[(Int, String)] = ParallelCollectionRDD[0] at makeRDD at <console>:24
   
   scala> rdd.mapValues(_+"|||").collect
   res2: Array[(Int, String)] = Array((2,a|||), (4,b|||), (1,c|||))
   
   

1.43.10 join(otherDataset,[numTasks]) 案例

1. 作用: 在类型为(K,V)和(K,W)对的RDD上调用, 返回一个相同的key对应的所有的元素对在一起的(K,(V,W))的RDD

   这里和SQL中的join很是相似.

2. 需求: 创建两个pairRDD ,并将key相同的数据聚合到一个元组

scala> rdd.collect
res3: Array[(Int, String)] = Array((2,a), (4,b), (1,c))

scala> val rdd1 = sc.makeRDD(Array((1,4),(2,5),(3,6)))
rdd1: org.apache.spark.rdd.RDD[(Int, Int)] = ParallelCollectionRDD[8] at makeRDD at <console>:24

scala> rdd.join(rdd1).collect
res4: Array[(Int, (String, Int))] = Array((1,(c,4)), (2,(a,5)))

1.43.11 cogroup(otherDataset,[numTasks]) 案例

1. 作用: 在类型(K,V)和(K,W)对的RDD上调用,返回一个(K,(iterable,Itable))类型的RDD

2. 需求: 创建两个 pairRDD , 并将key相同的数据聚合到一个 迭代器

   // 和SQL的外连接相似,以rdd为主,聚合另一个,若主rdd的k有对应的值,而从rdd没有值,则聚合后的从的rdd对应的值没有值. 反之,则相反
   scala> rdd.cogroup(rdd1).collect
   res6: Array[(Int, (Iterable[String], Iterable[Int]))] = Array((4,(CompactBuffer(b),CompactBuffer())), (1,(CompactBuffer(c),CompactBuffer(4))), (2,(CompactBuffer(a),CompactBuffer(5))), (3,(CompactBuffer(),CompactBuffer(6))))
   
   scala> rdd1.cogroup(rdd).collect
   res7: Array[(Int, (Iterable[Int], Iterable[String]))] = Array((4,(CompactBuffer(),CompactBuffer(b))), (1,(CompactBuffer(4),CompactBuffer(c))), (2,(CompactBuffer(5),CompactBuffer(a))), (3,(CompactBuffer(6),CompactBuffer())))
   
   

1.44 案例实操

1. 数据结构：时间戳，省份，城市，用户，广告，中间字段使用空格分割。

​ 样本如下： (提供20条数据)

1516609143867 6 7 64 16
1516609143869 9 4 75 18
1516609143869 1 7 87 12
1516609143869 2 8 92 9
1516609143869 6 7 84 24
1516609143869 1 8 95 5
1516609143869 8 1 90 29
1516609143869 3 3 36 16
1516609143869 3 3 54 22
1516609143869 7 6 33 5
1516609143869 8 2 91 27
1516609143869 0 5 66 5
1516609143869 1 3 33 6
1516609143869 6 2 97 21
1516609143869 5 2 95 24
1516609143869 8 9 73 11
1516609143869 4 8 62 15
1516609143869 5 5 40 23
1516609143869 6 6 53 17
1516609143869 3 0 86 21

2. 需求: 统计省份广告的top3

object Advertising {

    def main(args: Array[String]): Unit = {
        //创建spark的配置对象
        val conf: SparkConf = new SparkConf().setMaster("local").setAppName("Advertising")

        //创建spark上下文环境
        val sc = new SparkContext(conf)

        //读取文件
        val linesRDD: RDD[String] = sc.textFile("input/agent.log")

        //切割分组(按照各个省份的广告)
        val word1: RDD[((String, String), Int)] = linesRDD.map(line => {
            val str: Array[String] = line.split(" ")
            //省份
            val prov = str(1)
            //广告
            val adv = str(4)
            //返回以省份和广告位key , 1 为值的rdd
            ((prov, adv), 1)
        })
        //获取点击数
        val wordSum: RDD[((String, String), Int)] = word1.reduceByKey(_+_)

        //转换分组
        val wordReSum: RDD[(String, (String, Int))] = wordSum.map(t=>(t._1._1,(t._1._2,t._2)))

        //先分组,后排序
        val wordGroup: RDD[(String, Iterable[(String, Int)])] = wordReSum.groupByKey()

        //排序
        val top3: RDD[(String, List[(String, Int)])] = wordGroup.mapValues(items => {
            items.toList.sortWith((t1, t2) => {
                t1._2 > t2._2
                //拿到前三个
            }).take(3)
        })

        val result: Array[(String, List[(String, Int)])] = top3.collect()

        result.foreach(t=>{
            t._2.map(t1=>{
                println(t._1 +"-"+ t1._1+"-" + t1._2)
            })
        })
        
        //关闭资源
        sc.stop()
    }
}