Spark算子

1.手敲WC

reduceByKey

sc.textFile(“data/wccount.txt”)
.flatMap(.split(" "))
.map(x=>{
(x,1)
})
.reduceByKey(+_)
.foreach(println)
sc.stop()
groupBykey

sc.textFile(“data/wccount.txt”)
.flatMap(.split(" "))
.map(x=>{
(x,1)
})
.groupByKey()
.mapValues(.sum)
.foreach(println)
sc.stop()
groupBy(细节处理有两种)

sc.textFile(“data/wccount.txt”)
.flatMap(.split(" "))
.groupBy(x=>x)
// .mapValues(.size )
.map(x=>{
(x._1,x._2.size)
})
.foreach(println)
sc.stop()

2 map与mapPartitions 的区别

map是针对于每行

mapPartitions 是针对于每个分区

rdd.map((,1)).foreach(println)
rdd.map(a=> {
(a,1)
})
.foreach(println)
rdd.mapPartitions(partition => {
println("---------")
partition.map( * 2)
})
.foreach(println)
rdd.mapPartitionsWithIndex((index,partition)=>{
print("_________________")
partition.map(x=>{
s"$index,$x"
})
})
.foreach(println)

3.coalesce 与repartition 两个算子的作用以及区别和联系

repartition 重新定义分区数 调用coalesce方法，并且 第二个参数shuff默认是开启的

coalesce 默认的第二个参数 shuff是关闭的

二者都可以重新定义分区数，其中coalesce适用于判断当前分区数是否跟目标值》=，

使用coalesce可以是当前数《= 参数1中设置的副本数

val rdda =sc.makeRDD(List(1,2,3))
val rddb =sc.makeRDD(List(4,5,6))
//重置分区数
println(rdda.partitions.size)
println(rdda.repartition(3).partitions.size)

println(rdda.partitions.size)
//coalesce默认不开shuff  repatition 调用coalesce 并开启shuff 向下
println(rdda.coalesce(3,true).partitions.size)
println(rdda.coalesce(4).partitions.size)

4.使用zip算子是需要注意的是什么

spark rdd 中的zip 的需要 互相 a.zip(b) a b 的数量一致，否则报错

scala中的 原生zip 即使数量不一致 但是不会报错 ，只会显示匹配上的

//zip
val a = sc.makeRDD(List("aaa", "bbb", "ccc"))
val b=sc.makeRDD(List(1, 2, 3))
b.zip(a).foreach(println)
a.zip(b).zipWithIndex().foreach(println)

// scala原生zip
val zip_a=Array(“aaa”, “bbb”, “ccc”)
val zip_b = Array(1, 2, 3,4)
zip_b.zip(zip_a).foreach(println)

5.reduceByKey跟groupByKey的区别

groupByKey 会将key进行分组后 value 堆积在一起，后面需要用到聚合。（mapvalues）

reduceByKey有一个combine预聚合的处理，返回的是聚合后的数值（reduceByKey(+)）

// groupbykey
sc.makeRDD(List((“aaa”,1),(“bbb”,2 ),(“aaa”,3)))
.groupByKey()
// .mapValues(.sum)
.foreach(println)
//
// //reduceBykey
sc.makeRDD(List((“aaa”,1),(“bbb”,2 ),(“aaa”,3)))
.reduceByKey(+_)
.foreach(println)

6.使用RDD实现 join的多种方式

val rdda =sc.makeRDD(List((“aaa”,1),(“bbb”,2)))
val rddb =sc.makeRDD(List((“aaa” ,(“sh”))))
rdda.join(rddb).foreach(println)
println("-----------")
rdda.leftOuterJoin(rddb).foreach(println)
println("----------")
rdda.rightOuterJoin(rddb).foreach(println)
println("-----------")
rdda.fullOuterJoin(rddb).foreach(println)

7.aggreateByKey 与aggreate之间的区别与联系

aggreateByKey 用于kv 且初始值 在 分区间计算用不到

aggreate 初始值在分区间用到

二者都会将初始值用到分区中计算，第二第三参数都是分区中，分区间

val value = sc.parallelize(List(1, 2, 3, 4, 5, 6) ,6)
println(value.partitions.size)
value.mapPartitionsWithIndex((index,partition)=>{
partition.map(x=>{
s"$index,${x}"
})
}) .foreach(println)

println(value.aggregate(1)(+,+))
val rdd = sc.makeRDD(List((“a”, 1), (“a”, 2),(“a”, 4),(“a”, 6)),2)

rdd.aggregateByKey(3)(
(x,y) =>math.max(x,y),
(x,y) => x + y
).foreach(println)

8.reduceByKey与aggreateByKey之间的区别和联系

联系
都是按照key做聚合操作，都会在shuffle之前对数据做预聚合操作。
区别

reduceByKey：没有初始值，分区内和分区间的计算规则一致。
aggregateByKey：有初始值，初始值参与分区内和分区间的计算，分区内和分区间规则可以不一致。

补充：aggreate 初始值 在分区内计算 也在 分区间计算 3参

aggreateByKey 初始值 在分区内计算 不在分区间计算 3参

foldByKey 初始在 在分区内计算 不在分区间计算 2 参

combineByKey 初始值是第一个参数（Key的第一个值）c ，分区内计算(c + v) ，分区间计算（c1 +c2）c2是别的分区的初始值