Spark 常用算子

转载自本人语雀

https://www.yuque.com/docs/share/5d8d553b-7e3f-47ee-b5b7-f35479096f82?# 《Spark 常用算子》

 

Transformation（行动算子）
Value 型转换算子
●rdd.map(1 to _.length).collect
○map，第一个是输出每个参数的长度，从1到长度
■Array[scala.collection.immutable.Range.Inclusive] = Array(Range(1, 2, 3, 4), Range(1, 2, 3, 4), Range(1, 2, 3, 4, 5, 6, 7, 8), Range(1, 2, 3, 4))
●rdd.flatMap(1 to _.length).collect
○flatMap是将所有的长度放到一个数组中了
■Array[Int] = Array(1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4)
● mapPartitions
○var rdd2=rdd.mapPartitions(partition=>{partition.map(num => num * num)}).collect
○是对map中的各个数进行处理
●glom
○ 以分区为单位，将每个分区的值形成一个数组
● union 算子 或者 ++
○ 将两个 RDD 合并成一个 RDD，并不去重
■a.union(b).collect
■(a ++ b).collect
●group by
○ 输入分区与输出分区多对多型
○可以限制条件，对某个字段或者其他
● filter 算子
○过滤的 ，输出分区为输入分区子集型，可以做出限制条件
■hdfsRDD.flatMap(_.split("\\s+")).filter(_.contains("天亮教育")).collect.length
● distinct 算子
○全局去重的， 输出分区为输入分区子集型
●cache
○ cache 将 RDD 元素从磁盘缓存到内存。 相当于 persist(MEMORY_ONLY) 函数的功能
○主要应用在当 RDD 数据反复被使用的场景下
■ val c=a.union(b).cache
Key-Value 型转换算子
● mapValues 算子
○ 针对（Key,Value）型数据中的 Value 进行 Map 操作，而不对 Key 进行处理
○first.mapValues(item => item * 2).collect
● combineByKey 算子
○ def combineByKey[C]( createCombiner: (V) => C, mergeValue: (C, V) => C, mergeCombiners: (C, C) => C): RDD[(String, C)]
○createCombiner:对每个分区内的同组元素如何聚合，形成一个累加器
○mergeValue:将前边的累加器与新遇到的值进行合并的方法
○mergeCombiners:每个分区都是独立处理，故同一个键可以有多个累加器。如果有两个或者更多的分区都有对应同一个键的累加器，用方法将各个分区的结果进行合并。
○ reduceByKey 算子
■ 按 key 聚合后对组进行归约处理
○ join 算子
■ 对 Key-Value 结构的 RDD 进行按 Key 的 join 操作，最后将 V 部分做 flatmap 打平操作
行动算子(Action）
● foreach 算子
● saveAsTextFile 算子
○ 指定本地保存的目录
● collect 算子
● collectAsMap 算子
○ 相当于 toMap 操作，将分布式 RDD 的 kv 对形式返回成为一个的 scala map 集合，实际是 Driver 所在的机器节点，再针对该结果操作
● lookup 算子
○ 对（Key，Value）型的 RDD 操作，返回指定 Key 对应的元素形成的 Seq。
● reduce 算子
● fold 算子
○算子签名
预习算子
● cartesian 算子
○求迪克尔积
● subtract 算子
○计算两个RDD的差集
● sample 算子
○返回抽样后的子集
○sample(withReplacement : scala.Boolean, fraction : scala.Double，seed scala.Long)
■withReplacement：表示抽出样本后是否在放回去，true表示会放回去，这也就意味着抽出的样本可能有重复
■fraction ：抽出多少，这是一个double类型的参数,0-1之间，eg:0.3表示抽出30%
■seed：表示一个种子，根据这个seed随机抽取，一般情况下只用前两个参数就可以，那么这个参数是干嘛的呢，这个参数一般用于调试，有时候不知道是程序出问题还是数据出了问题，就可以将这个参数设置为定值
● takeSample 算子
○该方法仅在预期结果数组很小的情况下使用，因为所有数据都被加载到driver的内存中。
● persist 算子
○RDD 持久化有三个算子：cache、persist、checkpoint
■cache：把 RDD 持久化到内存 cache() = persist(StorageLevel.MEMORY_ONLY)
■persist：可以选择多种持久化方式
●初始化 StorageLevel 可以传入 5 个参数，分别对应是否存入磁盘、是否存入内存、是否使用堆外内存、是否不进行序列化，副本数（默认为 1）
■checkpoint : 可以把 RDD 持久化到 HDFS，同时切断 RDD 之间的依赖
● cogroup 算子
○group是对一个RDD进行操作,在一个RDD里面的多个分区进行shuffle,然后分到同一个组里面
○cogroup是对多个RDD进行操作,通过shuffle,然后把key相同的数据搞到一起,并且它的value不是一个迭代器,如果有两个 迭代器,那么返回的是一个对偶元组,对偶元组里面有两个compactBufffer,和两Iterator,如果有多个RDD,那么在cogroup的时候会产生多个compactBuffer,每个compactBufffer里面装有多个相同的key,聚合到一起存储对应value的值得特殊的集合,并且对应多个Iterator.

val rdd1 = sc.parallelize(List(("tom",1),("tom",2),("jerry",3),("kitty",2)))

val rdd2 = sc.parallelize(List(("jerry",2),("tom",1),("jerry",3),("kitty",2)))

rdd1.cogroup(rdd2).collect

● saveAsObjectFile 算子
○用于将RDD中的元素序列化成对象，存储到hdfs文件中
○识别逗号，十个为一组
●top
○sc.parallelize(Seq(2, 3, 4, 5, 6)).top(2)
○top算子是与takeOrdered算子的相反的操作，该算子返回RDD中的最大的k个元素
● aggregate 算子
○向count，sum之类的底层实现都是它
○aggragete算子作为spark的算子之一，虽然没有map，reduce算子使用的多但是也是一个不容忽略的算子，但是关于这个算子的用法很多解释都含糊不清 ，下面就记载下来以备以后观看。
○aggregate在scala语言中本来就存在，它的输入值和返回值的类型可以不一致，而reduce函数输入和输出数据类型 必须一致。首先他需要接受一个输入的初始值，然后再接受一个函数f1，把数据进行分块，按照分块计算各个分块之间的数据得到一个结果，它还有一个函数f2参数，使用这个参数对分块求得的结果再次进行计算。
○在spark中aggregate也是接受一个初始值，在各个分区之间应用f1函数，然后分区之间应用f2函数最后得到一个结果进行返回

def getAddition(fist:String,second:String):String ={

val s1 = fist.split("\\,")

val s2 = second.split("\\,")

val resSeq = for (i <- 0 until s1.length) yield (s1(i).toInt + s2(i).toInt).toString

resSeq.mkString(",")

}

val seq = Seq(("a1",("A","1,2,3")),("a2",("A","1,2,3")),("a3",("A","1,2,3")),("a4",("A","1,2,3")))

val res = seq.aggregate("0,0,0")( (x,y) => getAddition(x, y._2._2), (x,y) => getAddition(x,y))

println(res)