1.RDD 转换算子
RDD转换算子实际上就是换了名称的RDD方法
RDD 根据数据处理方式的不同将算子整体上分为 Value 类型、双 Value 类型和 Key-Value 类型
算子:Operator(操作)
- RDD的方法和Scala集合对象的方法不一样
- 集合对象的方法都是在同一个节点的内存中完成的
- RDD的方法可以将计算逻辑发送到Executor端(分布式节点)执行
- 为了区分不同的处理效果,所以将RDD的方法较为算子
- RDD的方法外部的操作都是在Driver端口执行的,而方法内部的逻辑代码实在Executor端执行的
Value 类型
就是123,单值的类型
-
map
- 函数签名
def map[U: ClassTag](f: T => U): RDD[U]
- 函数说明:将处理的数据逐条进行映射转换,这里的转换可以是类型的转换,也可以是值的转换。
val dataRDD: RDD[Int] = sparkContext.makeRDD(List(1,2,3,4)) val dataRDD1: RDD[Int] = dataRDD.map( num => { num * 2 } ) // 简写 val dataRDD1: RDD[Int] = dataRDD.map(_*2 ) val dataRDD2: RDD[String] = dataRDD1.map( num => { "" + num } )
小案例:从服务器日志数据 apache.log 中获取用户请求 URL 资源路径
def main(args: Array[String]): Unit = { val sparkConf = new SparkConf().setMaster("local[*]").setAppName("spark") val sparkContext = new SparkContext(sparkConf) val fileRDD: RDD[String] = sparkContext.textFile("datas/apache.log") // 长的字符串改成短的字符串 val mapRDD:RDD[String] = fileRDD.map( line => { val datas = line.split(" ") datas(6) } ) mapRDD.collect().foreach(println) sparkContext.stop() }
RDD的计算一个分区内的数据是一个一个执行逻辑,只有前面一个数据全部逻辑执行完毕后,才会执行下一个数据,分区内数据是有序的
不同分区之间数据的执行是无序的,如果说分区1为1与3,分区2为2与4,那么就会把一个分区执行完才走下一个分区
>>>>>>>>>3 >>>>>>>>>1 #########3 #########1 >>>>>>>>>4 >>>>>>>>>2 #########4 #########2
def main(args: Array[String]): Unit = {
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("spark")
val sparkContext = new SparkContext(sparkConf)
// 如果分区为一,数据是一个一个执行的,如果为2,就会无序执行
val dataRDD: RDD[Int] = sparkContext.makeRDD(List(1,2,3,4),2)
val dataRDD1: RDD[Int] = dataRDD.map(
num => {
println(">>>>>>>>>" + num)
num
}
)
val dataRDD2: RDD[Int] = dataRDD1.map(
num => {
println("#########" + num)
num
}
)
dataRDD2.collect()
sparkContext.stop()
}
-
mapPartitions
- 函数签名
def mapPartitions[U: ClassTag]( f: Iterator[T] => Iterator[U], preservesPartitioning: Boolean = false): RDD[U]
- 函数说明:
存在一个数据缓冲区,将待处理的数据以分区为单位发送到计算节点(内存)进行处理,这里的处理是指可以进行任意的处理,哪怕是过滤数据。但是会将整个分区的数据加载到内存中进行引用,因为存在对象的引用,所以处理完的数据是不会释放掉的,因此如果内存小且数据量大,容易出现内存溢出
有多少分区里面的代码就执行多少次,iter表示单个分区里面的全部数据
val dataRDD1: RDD[Int] = dataRDD.mapPartitions( iter => { iter.map(_ * 2) } ) val dataRDD1: RDD[Int] = dataRDD.mapPartitions( iter => { iter.filter(_==2) } )
小案例:获取每个数据分区的最大值
def main(args: Array[String]): Unit = { val sparkConf = new SparkConf().setMaster("local[*]").setAppName("spark") val sparkContext = new SparkContext(sparkConf) val dataRDD: RDD[Int] = sparkContext.makeRDD(List(1, 2, 3, 4), 2) val dataRDD1: RDD[Int] = dataRDD.mapPartitions( iter => { List(iter.max).iterator } ) dataRDD1.collect().foreach(println) sparkContext.stop() }
问题:map 和 mapPartitions 的区别?
- 数据处理角度:Map 算子是分区内一个数据一个数据的执行,类似于串行操作。而 mapPartitions 算子 是以分区为单位进行批处理操作。
- 功能的角度:Map 算子主要目的将数据源中的数据进行转换和改变。但是不会减少或增多数据。 MapPartitions 算子需要传递一个迭代器,返回一个迭代器,没有要求的元素的个数保持不变, 所以可以增加或减少数据
- 性能的角度:Map 算子因为类似于串行操作,所以性能比较低,而是 mapPartitions 算子类似于批处理,所以性能较高。但是 mapPartitions 算子会长时间占用内存,那么这样会导致内存可能不够用,出现内存溢出的错误。所以在内存有限的情况下,不推荐使用。使用 map 操作。
-
mapPartitionsWithIndex
- 函数签名
def mapPartitionsWithIndex[U: ClassTag]( f: (Int, Iterator[T]) => Iterator[U], preservesPartitioning: Boolean = false): RDD[U]
- 函数说明
mapPartitions
不能手动指定分区,因此,这个方法就在参数增加了分区编号,将待处理的数据以分区为单位发送到计算节点进行处理,这里的处理是指可以进行任意的处理,哪怕是过滤数据,在处理时同时可以获取当前分区索引。// 把每一个数据的分区号与数据都拿出来,默认看你计算机cpu核数 val dataRDD: RDD[Int] = sparkContext.makeRDD(List(1, 2, 3, 4)) val dataRDD1 = dataRDD.mapPartitionsWithIndex( (index, iter) => { iter.map( num => { (index,num) } ) } )
小案例:获取第二个数据分区的数据
val dataRDD1: RDD[Int] = dataRDD.mapPartitionsWithIndex( (index, iter) => { if (index == 1) { iter } else { Nil.iterator } } )
-
flatMap
- 函数签名
def flatMap[U: ClassTag](f: T => TraversableOnce[U]): RDD[U]
- 函数说明
将处理的数据进行扁平化后再进行映射处理,所以算子也称之为扁平映射
val dataRDD = sparkContext.makeRDD(List("hello scala","hello spark"),1) val dataRDD1 = dataRDD.flatMap( s => { s.split(" ") } )
小案例:将 List(List(1,2),3,List(4,5))进行扁平化操作
def main(args: Array[String]): Unit = { val sparkConf = new SparkConf().setMaster("local[*]").setAppName("spark") val sparkContext = new SparkContext(sparkConf) val dataRDD = sparkContext.makeRDD(List(List(1,2),3,List(4,5)),1) val dataRDD1 = dataRDD.flatMap( // 使用模式匹配,3不是集合就把3变成集合类型 data => { data match{ case list: List[_] => list case something => List(something) } } ) dataRDD1.collect().foreach(println) sparkContext.stop() }
-
glom
- 函数签名
def glom(): RDD[Array[T]]
- 函数说明
将同一个分区的数据直接转换为相同类型的内存集合进行处理,分区不变
val dataRDD = sparkContext.makeRDD(List(1,2,3,4),1) val dataRDD1:RDD[Array[Int]] = dataRDD.glom()
小案例:计算所有分区最大值求和(分区内取最大值,分区间最大值求和)
问题的关键就是将一个分区内的数据当成一个数组
def main(args: Array[String]): Unit = { val sparkConf = new SparkConf().setMaster("local[*]").setAppName("spark") val sparkContext = new SparkContext(sparkConf) val dataRDD = sparkContext.makeRDD(List(1, 2, 3, 4), 2) // 此时一个分区的数据,我们就将其变为了集合,一旦变成了集合,集合有大量的方法以供我们使用 val glomRDD: RDD[Array[Int]] = dataRDD.glom() // 此时每个分区的最大值已经取出来了 val MaxRDD:RDD[Int] = glomRDD.map(_.max) println(MaxRDD.collect().sum) sparkContext.stop() }
-
groupBy
- 函数签名
def groupBy[K](f: T => K)(implicit kt: ClassTag[K]): RDD[(K, Iterable[T])]
- 函数说明
将数据根据指定的规则进行分组, 分区默认不变,但是数据会被打乱重新组合,我们将这样 的操作称之为 shuffle。极限情况下,数据可能被分在同一个分区中,一个组的数据在一个分区中,但是并不是说一个分区中只有一个组,groupBy会将数据源中的每一个数据进行分组判断,根据返回的分组key进行分组,相同的key值的数据会放置在一个组中
分组与分区没有必然关系
def main(args: Array[String]): Unit = { // 根据奇偶进行分组 val sparkConf = new SparkConf().setMaster("local[*]").setAppName("spark") val sparkContext = new SparkContext(sparkConf) val dataRDD = sparkContext.makeRDD(List(1, 2, 3, 4), 2) val groupRDD = dataRDD.groupBy(_ % 2) groupRDD.collect().foreach(println) sparkContext.stop() }
小案例:将 List(“Hello”, “hive”, “hbase”, “Hadoop”)根据单词首写字母进行分组。
def main(args: Array[String]): Unit = { // 根据首字母进行分组 val sparkConf = new SparkConf().setMaster("local[*]").setAppName("spark") val sparkContext = new SparkContext(sparkConf) val dataRDD = sparkContext.makeRDD(List("Hello", "hive", "hbase", "Hadoop"), 2) val groupRDD = dataRDD.groupBy(_.charAt(0)) groupRDD.collect().foreach(println) sparkContext.stop() }
小案例:从服务器日志数据 apache.log 中获取每个时间段访问量。
def main(args: Array[String]): Unit = { // 根据首字母进行分组 val sparkConf = new SparkConf().setMaster("local[*]").setAppName("spark") val sparkContext = new SparkContext(sparkConf) val fileRDD: RDD[String] = sparkContext.textFile("datas/apache.log") val value = fileRDD.map( line => line.split(" ")(3).substring(11,13) ).groupBy(word => word).map(kv => (kv._1, kv._2.size)) value.collect().foreach(println) sparkContext.stop() } def main(args: Array[String]): Unit = { // 根据首字母进行分组 val sparkConf = new SparkConf().setMaster("local[*]").setAppName("spark") val sparkContext = new SparkContext(sparkConf) val fileRDD: RDD[String] = sparkContext.textFile("datas/apache.log") val value = fileRDD.map( line => (line.split(" ")(3).substring(11,13),1) ).groupBy(_._1).map(kv => (kv._1,kv._2.size)) value.collect().foreach(println) sparkContext.stop() }
-
filter
- 函数签名
def filter(f: T => Boolean): RDD[T]
- 函数说明
将数据根据指定的规则进行筛选过滤,符合规则的数据保留,不符合规则的数据丢弃。 当数据进行筛选过滤后,分区不变,但是分区内的数据可能不均衡,生产环境下,可能会出现
数据倾斜
。val dataRDD = sparkContext.makeRDD(List(1,2,3,4),1) val dataRDD1 = dataRDD.filter(_%2 == 0)
-
sample
- 函数签名
def sample( withReplacement: Boolean, fraction: Double, seed: Long = Utils.random.nextLong): RDD[T]
- 函数说明
根据指定的规则从数据集中抽取数据
val dataRDD = sparkContext.makeRDD(List(1,2,3,4),1) // 抽取数据不放回(伯努利算法) // 伯努利算法:又叫 0、1 分布。例如扔硬币,要么正面,要么反面。 // 具体实现:根据种子和随机算法算出一个数和第二个参数设置几率比较,小于第二个参数要,大于不要 // 第一个参数:抽取的数据是否放回,false:不放回 // 第二个参数:抽取的几率,范围在[0,1]之间,0:全不取;1:全取; // 第三个参数:随机数种子 val dataRDD1 = dataRDD.sample(false, 0.5) // 抽取数据放回(泊松算法) // 第一个参数:抽取的数据是否放回,true:放回;false:不放回 // 第二个参数:重复数据的几率,范围大于等于 0.表示每一个元素被期望抽取到的次数 // 第三个参数:随机数种子 val dataRDD2 = dataRDD.sample(true, 2) 如果第三个参数的随机数种子确定,那么随机就会被确定,不管执行多少次结果都一样
问题:这个有啥用,抽奖吗?
使用场景:数据倾斜的时候可以利用
-
distinct
- 函数签名
def distinct()(implicit ord: Ordering[T] = null): RDD[T] def distinct(numPartitions: Int)(implicit ord: Ordering[T] = null): RDD[T]
- 函数说明
将数据集中重复的数据去重
val dataRDD = sparkContext.makeRDD(List(1,2,3,4,1,2),1) val dataRDD1 = dataRDD.distinct() val dataRDD2 = dataRDD.distinct(2)
-
coalesce
- 函数签名
def coalesce(numPartitions: Int, shuffle: Boolean = false, partitionCoalescer: Option[PartitionCoalescer] = Option.empty) (implicit ord: Ordering[T] = null) : RDD[T]
- 函数说明
根据数据量缩减分区,用于大数据集过滤后,提高小数据集的执行效率 当 spark 程序中,存在过多的小任务的时候,可以通过 coalesce 方法,收缩合并分区,减少分区的个数,减小任务调度成本,第二个参数shuffle为true,就会重现打乱
val dataRDD = sparkContext.makeRDD(List(1,2,3,4,1,2),6) // 从6个分区缩小从2个分区 val dataRDD1 = dataRDD.coalesce(2)
**问题:**我想要扩大分区,怎么办?
val dataRDD = sparkContext.makeRDD(List(1,2,3,4,5,6),2) // 从6个分区缩小从2个分区,一定要使用shuffle设定为true,不然只是多了一个分区没数据,没有任何意义 val dataRDD1 = dataRDD.coalesce(3,true)
简化操作:缩小分区使用
coalesce
,分区就使用repartition
-
repartition
- 函数签名
def repartition(numPartitions: Int)(implicit ord: Ordering[T] = null): RDD[T]
- 函数说明
该操作内部其实执行的是 coalesce 操作,参数 shuffle 的默认值为 true。无论是将分区数多的 RDD 转换为分区数少的 RDD,还是将分区数少的 RDD 转换为分区数多的 RDD,repartition 操作都可以完成,因为无论如何都会经 shuffle 过程。
val dataRDD = sparkContext.makeRDD(List(1,2,3,4,1,2),2) val dataRDD1 = dataRDD.repartition(4)
**问题:**coalesce 和 repartition 区别?
无区别,缩小分区使用
coalesce
,分区就使用repartition
-
sortBy
- 函数签名
def sortBy[K]( f: (T) => K, ascending: Boolean = true, // 默认清空下是true升序,改成false就是降序 numPartitions: Int = this.partitions.length) (implicit ord: Ordering[K], ctag: ClassTag[K]): RDD[T]
- 函数说明
该操作用于排序数据。在排序之前,可以将数据通过 f 函数进行处理,之后按照 f 函数处理 的结果进行排序,默认为升序排列。排序后新产生的 RDD 的分区数与原 RDD 的分区数一 致。中间存在 shuffle 的过程
val dataRDD = sparkContext.makeRDD(List(1,2,3,4,1,2),2) val dataRDD1 = dataRDD.sortBy(num=>num, false, 4)
双 Value 类型
-
intersection
- 函数签名
def intersection(other: RDD[T]): RDD[T]
- 函数说明
对源 RDD 和参数 RDD 求交集后返回一个新的 RDD
val dataRDD1 = sparkContext.makeRDD(List(1,2,3,4)) val dataRDD2 = sparkContext.makeRDD(List(3,4,5,6)) val dataRDD = dataRDD1.intersection(dataRDD2)
**问题:**如果两个 RDD 数据类型不一致怎么办?
-
union
- 函数签名
def union(other: RDD[T]): RDD[T]
- 函数说明
对源 RDD 和参数 RDD 求并集后返回一个新的 RDD
val dataRDD1 = sparkContext.makeRDD(List(1,2,3,4)) val dataRDD2 = sparkContext.makeRDD(List(3,4,5,6)) val dataRDD = dataRDD1.union(dataRDD2)
**问题:**如果两个 RDD 数据类型不一致怎么办?
-
subtract
- 函数签名
def subtract(other: RDD[T]): RDD[T]
- 函数说明
以一个 RDD 元素为主,去除两个 RDD 中重复元素,将其他元素保留下来。求差集
val dataRDD1 = sparkContext.makeRDD(List(1,2,3,4)) val dataRDD2 = sparkContext.makeRDD(List(3,4,5,6)) val dataRDD = dataRDD1.subtract(dataRDD2)
**问题:**如果两个 RDD 数据类型不一致怎么办?
-
zip
- 函数签名
def zip[U: ClassTag](other: RDD[U]): RDD[(T, U)]
- 函数说明
将两个 RDD 中的元素,以键值对的形式进行合并。其中,键值对中的 Key 为第 1 个 RDD 中的元素,Value 为第 2 个 RDD 中的相同位置的元素。
val dataRDD1 = sparkContext.makeRDD(List(1,2,3,4)) val dataRDD2 = sparkContext.makeRDD(List(3,4,5,6)) val dataRDD = dataRDD1.zip(dataRDD2) 打印输出 (1,3) (2,4) (3,5) (4,6)
问题:
-
如果两个 RDD 数据类型不一致怎么办?
-
如果两个 RDD 数据分区不一致怎么办?
-
如果两个 RDD 分区数据数量不一致怎么办?
解答:交集并集差集要求两边数据源必须一直保持一样
拉链时候两个数据源要求分区数量保持一致,每个分区的元素数量也要一致
Key-Value 类型
-
partitionBy
- 函数签名
def partitionBy(partitioner: Partitioner): RDD[(K, V)]
- 函数说明
将数据按照指定 Partitioner 重新进行分区。Spark 默认的分区器是 HashPartitioner
val rdd: RDD[(Int, String)] = sc.makeRDD(Array((1,"aaa"),(2,"bbb"),(3,"ccc")),3) import org.apache.spark.HashPartitioner val rdd2: RDD[(Int, String)] =rdd.partitionBy(new HashPartitioner(2))
问题:
- 如果重分区的分区器和当前 RDD 的分区器一样怎么办?
- Spark 还有其他分区器吗?
- 如果想按照自己的方法进行数据分区怎么办?
解答:
- 分区器一样的话,就会什么也不做
- 有
- 自己写一个分区器,查看HashPartitioner的源码,自己仿写
-
reduceByKey
- 函数签名
def reduceByKey(func: (V, V) => V): RDD[(K, V)] def reduceByKey(func: (V, V) => V, numPartitions: Int): RDD[(K, V)]
- 函数说明
可以将相同的key的数据进行value数据的聚合操作,如果key只有一个,就不能进行两两运算,要求分区内与分区间计算规则相同
val dataRDD1 = sparkContext.makeRDD(List(("a",1),("a",2),("b",3))) // 第一个_代表第一个value值,第二个_代表第二个value值,算完之后的值依次往下与下一个计算 val dataRDD2 = dataRDD1.reduceByKey(_+_) val dataRDD3 = dataRDD1.reduceByKey(_+_,2)
-
groupByKey
- 函数签名
def groupByKey(): RDD[(K, Iterable[V])] def groupByKey(numPartitions: Int): RDD[(K, Iterable[V])] def groupByKey(partitioner: Partitioner): RDD[(K, Iterable[V])]
- 函数说明
将数据源的数据根据相同的key 对 value 进行分组,相同的key的数据分在一个组,形成一个元组,元组的第一个元素就是key,元组中的第二个元素就是相同key的value的集合
val dataRDD1 = sparkContext.makeRDD(List(("a",1),("b",2),("c",3))) val dataRDD2 = dataRDD1.groupByKey() val dataRDD3 = dataRDD1.groupByKey(2) val dataRDD4 = dataRDD1.groupByKey(new HashPartitioner(2))
思考一个问题:reduceByKey 和 groupByKey 的区别?
从 shuffle 的角度:reduceByKey 和 groupByKey 都存在 shuffle 的操作,但是 reduceByKey 可以在 shuffle 前对分区内相同 key 的数据进行预聚合(combine)功能,这样会减少落盘的数据量,而 groupByKey 只是进行分组,不存在数据量减少的问题,reduceByKey 性能比较高。
从功能的角度:reduceByKey 其实包含分组和聚合的功能。GroupByKey 只能分组,不能聚合,所以在分组聚合的场合下,推荐使用 reduceByKey,如果仅仅是分组而不需要聚合。那么还是只能使用 groupByKey
核心区别:reduceByKey会有一个预处理预聚合,聚合完成后,需要落盘的数据就大大减少
小案例:WordCount
-
aggregateByKey
- 函数签名
def aggregateByKey[U: ClassTag](zeroValue: U)(seqOp: (U, V) => U, combOp: (U, U) => U): RDD[(K, U)]
- 函数说明
将数据根据不同的规则进行分区内计算和分区间计算,分区内与分区间可以有不同的规则,最终返回数据结果与初始值的类型一致
val dataRDD1 = sparkContext.makeRDD(List(("a",1),("b",2),("c",3))) val dataRDD2 = dataRDD1.aggregateByKey(0)(_+_,_+_)
小案例:取出每个分区内相同 key 的最大值然后分区间相加
// TODO : 取出每个分区内相同 key 的最大值然后分区间相加 // aggregateByKey 算子是函数柯里化,存在两个参数列表 // 1. 第一个参数列表中的参数表示初始值,主要用于碰见第一个key的时候,和value进行分区内计算,提供两两比较的初始值 // 2. 第二个参数列表中含有两个参数 // 2.1 第一个参数表示分区内的计算规则 // 2.2 第二个参数表示分区间的计算规则 val rdd = sc.makeRDD(List(("a",1),("a",2),("c",3),("b",4),("c",5),("c",6)),2) val resultRDD = rdd.aggregateByKey(10)( (x, y) => math.max(x,y), (x, y) => x + y ) resultRDD.collect().foreach(println)
小案例:计算相同key的数据的平均值 => (a , 3) (b , 4)
def main(args: Array[String]): Unit = { // 根据首字母进行分组 val sparkConf = new SparkConf().setMaster("local[*]").setAppName("spark") val sparkContext = new SparkContext(sparkConf) // 第一个零是计算的初始值,第二个零是出现次数 val resultRDD = rdd.aggregateByKey((0,0))( // 第一次的t为a.(0,0)去除key的初始值(0,0),v为第二个a,1去除key的1,依次往下计算 (t,v) => { (t._1 + v,t._2 +1 ) }, // 因为是分区间,所以全是a的,第一次的t1为a,(3,2)去除a的(3,2),t2为a,(6,1)去除a的(6,1) (t1,t2) =>{ (t1._1 + t2._1,t1._2 + t2._2) } ) resultRDD.collect().foreach(println) // key不变,只对value做改变 resultRDD.mapValues { case (num, cnt) => { num / cnt } }.collect().foreach(println) sparkContext.stop() }
求平均值图解
思考一个问题:分区内计算规则和分区间计算规则相同怎么办?(WordCount)
val resultRDD = rdd.aggregateByKey(10)( (x, y) => x + y, (x, y) => x + y )
或者使用下面的
foldByKey
-
foldByKey
- 函数签名
def foldByKey(zeroValue: V)(func: (V, V) => V): RDD[(K, V)]
- 函数说明
当分区内计算规则和分区间计算规则相同时,aggregateByKey 就可以简化为 foldByKey
val dataRDD1 = sparkContext.makeRDD(List(("a",1),("b",2),("c",3))) val dataRDD2 = dataRDD1.foldByKey(0)(_+_)
-
combineByKey
- 函数签名
def combineByKey[C]( createCombiner: V => C, // 将相同key的第一个数据进行结构的转换,实现操作 mergeValue: (C, V) => C, // 分区内的计算规则 mergeCombiners: (C, C) => C // 分区间的计算规则 ): RDD[(K, C)]
- 函数说明
剔除了
aggregateByKey
中的初始值概念,最通用的对 key-value 型 rdd 进行聚集操作的聚集函数(aggregation function)。类似于 aggregate(),combineByKey()允许用户返回值的类型与输入不一致。小练习:将数据 List((“a”, 88), (“b”, 95), (“a”, 91), (“b”, 93), (“a”, 95), (“b”, 98))求每个 key 的平均值
val list: List[(String, Int)] = List(("a", 88), ("b", 95), ("a", 91), ("b", 93),("a", 95), ("b", 98)) val input: RDD[(String, Int)] = sc.makeRDD(list, 2) val combineRdd: RDD[(String, (Int, Int))] = input.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) )
问题:reduceByKey、foldByKey、aggregateByKey、combineByKey 的区别?
-
reduceByKey:相同 key 的第一个数据不进行任何计算,分区内和分区间计算规则相同
-
FoldByKey:相同 key 的第一个数据和初始值进行分区内计算,分区内和分区间计算规则相同
-
AggregateByKey:相同 key 的第一个数据和初始值进行分区内计算,分区内和分区间计算规则可以不相同
-
CombineByKey:当计算时,发现数据结构不满足要求时,可以让第一个数据转换结构。分区内和分区间计算规则不相同。
小案例:计算相同key的数据的平均值 => (a , 3) (b , 4)
def main(args: Array[String]): Unit = { // 根据首字母进行分组 val sparkConf = new SparkConf().setMaster("local[*]").setAppName("spark") val sparkContext = new SparkContext(sparkConf) val rdd = sparkContext.makeRDD(List(("a", 1), ("a", 2), ("b", 3), ("b", 4), ("b", 5),("a", 6)), 2) // 第一个零是计算的初始值,第二个零是出现次数 val resultRDD = rdd.combineByKey( v => (v,1), (x : (Int,Int),y) =>{ (x._1 + y,x._2 +1 ) }, (t1: (Int,Int),t2: (Int,Int)) => { (t1._1 + t2._1,t1._2+t2._2) } ) resultRDD.mapValues{ case (num, cnt) => { num / cnt } }.collect().foreach(println) sparkContext.stop() }
-
sortByKey
- 函数签名
def sortByKey(ascending: Boolean = true, numPartitions: Int = self.partitions.length) : RDD[(K, V)]
- 函数说明
在一个( K , V )的 RDD 上调用,K 必须实现 Ordered 接口(特质),返回一个按照 key 进行排序的
val dataRDD1 = sparkContext.makeRDD(List(("a",1),("b",2),("c",3))) val sortRDD1: RDD[(String, Int)] = dataRDD1.sortByKey(true) val sortRDD1: RDD[(String, Int)] = dataRDD1.sortByKey(false)
小案例:设置 key 为自定义类 User
-
join
- 函数签名
def join[W](other: RDD[(K, W)]): RDD[(K, (V, W))]
- 函数说明
在类型为(K,V)和(K,W)的 RDD 上调用,返回一个相同 key 对应的所有元素连接在一起的 (K,(V,W))的 RDD
两个不同数据源的数据,相同的key的value会连接在一起,形成元组
如果两个数据源中key没有匹配上,那么数据不会出现在结果中
如果两个数据源中key有多个相同的,可能会依次匹配,出现笛卡尔积,数据呈现几何倍的增长
val rdd: RDD[(Int, String)] = sc.makeRDD(Array((1, "a"), (2, "b"), (3, "c"))) val rdd1: RDD[(Int, Int)] = sc.makeRDD(Array((1, 4), (2, 5), (3, 6))) rdd.join(rdd1).collect().foreach(println) ################# (1,(a,4)) (2,(b,5)) (3,(c,6))
-
leftOuterJoin
- 函数签名
def leftOuterJoin[W](other: RDD[(K, W)]): RDD[(K, (V, Option[W]))]
- 函数说明
类似于 SQL 语句的左外连接
val dataRDD1 = sparkContext.makeRDD(List(("a",1),("b",2),("c",3))) val dataRDD2 = sparkContext.makeRDD(List(("a",1),("b",2),("c",3))) val rdd: RDD[(String, (Int, Option[Int]))] = dataRDD1.leftOuterJoin(dataRDD2)
-
cogroup
- 函数签名
def cogroup[W](other: RDD[(K, W)]): RDD[(K, (Iterable[V], Iterable[W]))]
- 函数说明
相同的key放在一个组当中,然后连接在一起,在类型为(K,V)和(K,W)的 RDD 上调用,返回一个(K,(Iterable,Iterable))类型的 RDD
val dataRDD1 = sparkContext.makeRDD(List(("a",1),("a",2),("c",3))) val dataRDD2 = sparkContext.makeRDD(List(("a",1),("c",2),("c",3))) val value: RDD[(String, (Iterable[Int], Iterable[Int]))] = dataRDD1.cogroup(dataRDD2) value.collect().foreach(println) 控制台打印 (a,(CompactBuffer(1, 2),CompactBuffer(1))) (c,(CompactBuffer(3),CompactBuffer(2, 3)))
案例实操
-
数据准备
agent.log:时间戳,省份,城市,用户,广告,中间字段使用空格分隔。
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
-
需求描述:统计出每一个省份每个广告被点击数量排行的 Top3
-
需求分析
缺什么补什么,多什么删什么
-
功能实现
package com.atguigu.bigdata.spark.core
import org.apache.spark.{SparkConf, SparkContext}
import org.apache.spark.rdd.RDD
object Spark02_Demo1 {
def main(args: Array[String]): Unit = {
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("spark")
val sparkContext = new SparkContext(sparkConf)
// 获取原始数据 时间戳,省份,城市,用户,广告
val dataRDD = sparkContext.textFile("datas/agent.log")
// 将结构数据进行转换 变成((省份,广告),1),进行分组聚合
val mapRDD = dataRDD.map{
line => {
val datas = line.split(" ")
((datas(1), datas(4)), 1)
}
}
val reduceRDD = mapRDD.reduceByKey(_+_)
// 将聚合的结果进行结构转换 ((省份,广告),1) => (省份,(广告,sum))
val newMapRDD = reduceRDD.map {
// 有特定的格式就使用模式匹配
case ((prv, ad), sum) => {
(prv, (ad, sum))
}
}
// 将转换结构后的数据根据省份进行分组 (省份,[(广告1,sum),(广告2,sum),(广告3,sum)])
val groupRDD: RDD[(String, Iterable[(String, Int)])] = newMapRDD.groupByKey()
// 将分组后的数据组内排序,然后取前3位
val resultRDD = groupRDD.mapValues(
iter => {
// 迭代器需要转化为集合
iter.toList.sortBy(_._2)(Ordering.Int.reverse).take(3)
}
)
resultRDD.collect().foreach(println)
sparkContext.stop()
}
}