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"
i
n
d
e
x
,
index,
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"
i
n
d
e
x
,
{index},
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是别的分区的初始值