RDD 算子补充
一、RDD算子补充
1、mapPartitions
mapPartitions的输入函数作用于每个分区, 也就是把每个分区中的内容作为整体来处理。 (map是把每一行)
mapPartitions一次处理一个分区的所有数据,而map算子一次处理分区中的一条数据,所以mapPartitions处理数据的速度比map快,如果RDD分区的数据很庞大,用mapPartitions容易造成内存溢出,
如果RDD分区数据量小,从而提升速度的角度考虑,可以使用mapPartitions算子。
JAVA实现:
scala实现:
2、mapPartitionsWithIndex
mapPartitionsWithIndex方法与mapPartitions方法功能类似
不同的是mapPartitionsWithIndex还会对原始分区的索引进行 追踪, 这样就能知道分区所对应的元素 。 方法的参数为一个函数, 函数的输入为整型索引和迭代器。
JAVA实现:
public static void mapPartitionsWithIndex(){ SparkConf conf=new SparkConf().setAppName("mapPartitionsWithIndex").setMaster("local"); JavaSparkContext sc=new JavaSparkContext(conf); //模拟数据并创建初始RDD JavaRDD<String> datas = sc.parallelize(Arrays.asList("张三","李四","李思","李斯"),2); JavaRDD<String> result = datas.mapPartitionsWithIndex(new Function2<Integer, Iterator<String>, Iterator<String>>() { /** * */ private static final long serialVersionUID = 1L; public Iterator<String> call(Integer index, Iterator<String> datass) throws Exception { // TODO Auto-generated method stub ArrayList<String> arrayList = new ArrayList<String>(); while(datass.hasNext()){ String info="第"+index+"分区的数据:"+datass.next(); arrayList.add(info); } return arrayList.iterator(); } }, false); List<String> collect = result.collect(); for(String a:collect){ System.out.println(a); } sc.close(); }
scala实现:
def mapPartitionsWithIndex: Unit ={ val conf=new SparkConf().setAppName("cogroup").setMaster("local") val sc=new SparkContext(conf) val a=sc.parallelize(Array("liu","zhao","wang","li"),2) val result=a.mapPartitionsWithIndex((x,y)=>{ val arraybuffer=ArrayBuffer[String]() while(y.hasNext){ val info=x+" "+y.next() arraybuffer+=info } arraybuffer.iterator }) result.foreach(x=>{ println(x) }) sc.stop() }
3、mapValues运算
可以针对RDD内每一组(key,value)进行运算, 并且产生另外一个RDD。
例如: 将每一组( key,value) 的value进行平方运算
kvRDD1.mapValues(x => x*x).collect
4、union
union方法( 等价于“++”) 是将两个RDD取并集, 取并集的过程中不 会把相同元素去掉。 union操作是输入分区与输出分区多对一模式。
scala实现:
def union: Unit ={ val conf=new SparkConf().setAppName("union").setMaster("local") val sc=new SparkContext(conf) val rdd1=sc.parallelize(Array((1,2),(2,3),(3,4))) val rdd2=sc.parallelize(Array((1,2),(4,3),(5,4))) val result=rdd1.union(rdd2) result.foreach(x=>{ println(x._1+" "+x._2) }) sc.stop() }
结果:
1 2
2 3
3 4
1 2
4 3
5 4
5、distinct
distinct方法是将RDD中重复的元素去掉, 只留下唯一的RDD元素。
6、intersection交集运算
intersection方法可以获取两个RDD中相同的数据
def intersection: Unit ={ val conf=new SparkConf().setAppName("intersection").setMaster("local") val sc=new SparkContext(conf) val rdd1=sc.parallelize(Array((1,2),(2,3),(3,4))) val rdd2=sc.parallelize(Array((1,2),(4,3),(5,4))) val result=rdd1.intersection(rdd2).foreach(x=>{ println(x._1+" "+x._2)}) sc.stop() }
7、subtract差集运算
intRDD1.subtract(intRDD2).collect()
intRDD1是List(3,1,2,5,5), 扣除intRDD2 List(5,6)重复的部分5, 所 以结果是(1,2,3)
//把rdd1 rdd2中的相同项,从rdd1中去除掉
def subtract: Unit ={ val conf=new SparkConf().setAppName("intersection").setMaster("local") val sc=new SparkContext(conf) val rdd1=sc.parallelize(Array((1,2),(2,3),(3,4))) val rdd2=sc.parallelize(Array((1,2),(4,3),(5,4))) rdd1.subtract(rdd2).foreach(x=>{ println(x._1+" "+x._2)}) sc.stop() }
8、aggregateByKey
reduceByKey认为是aggregateByKey的简化版
aggregateByKey最重要的一点是, 多提供了一个函数, Seq Function
可以控制如何对每个partition中的数据进行先聚合, 类似于mapreduce中的map-side combine, 然后才是对所有partition中的数据进行全局聚合
aggregateByKey, 分为三个参数:
第一个参数是, 每个key的初始值
第二个是个函数, Seq Function, 如何进行shuffle map-side的本地聚合
第三个是个函数, Combiner Function, 如何进行shuffle reduce-side的全局聚合
Java实现:
scala实现:
//在调用aggregateByKey算子时,第二、三两个参数时(这两个参数传入的是函数),运用柯里化的方式,不需要给函数传参 def aggregateByKey: Unit ={ val conf=new SparkConf().setAppName("aggregateByKey").setMaster("local") val sc=new SparkContext(conf) val lines=sc.textFile("file:///home/hadoop/product.txt") def seq(num1:Int,num2:Int):Int={ num1+num2 } def comb(num1:Int,num2:Int):Int={ num1+num2 } lines.map(x=>(x,1)).aggregateByKey(0)(seq,comb).foreach(x=>{ println(x._1+" "+x._2) }) }
9、cartesian
cartesian, 中文名笛卡尔乘积
比如说两个RDD, 分别有10条数据, 用了cartesian算子以后,两个RDD的每一条数据都会和另外一个RDD的每一条数据执行一次join,最终组成了一个笛卡尔乘积
def cartesian: Unit ={ val conf=new SparkConf().setAppName("cartesian").setMaster("local") val sc=new SparkContext(conf) val rdd1=sc.parallelize(Array((1,2),(2,3),(3,4))) val rdd2=sc.parallelize(Array((1,2),(4,3),(5,4))) rdd1.cartesian(rdd2).foreach(x=>{ println(x._1+" "+x._2) }) }
(1,2) (1,2)
(1,2) (4,3)
(1,2) (5,4)
(2,3) (1,2)
(2,3) (4,3)
(2,3) (5,4)
(3,4) (1,2)
(3,4) (4,3)
(3,4) (5,4)
10、coalesce
coalesce算子, 功能是将RDD的partition缩减, 将一定量的数据压缩到更少的partition中去。建议的使用场景, 配合filter算子使用
使用filter算子过滤掉很多数据以后, 比如30%的数据, 出现了很多partition中的数据不均匀的情况
此时建议使用coalesce算子, 压缩rdd的partition数量, 从而让各个partition中的数 据都更加的紧凑
缺点:只能减少分区数,不能增加分区数
11、repartition
repartition算子, 用于任意将rdd的partition增多或者减少
与coalesce不同之处在于, coalesce仅仅能将rdd的partition变少, 但是 repartition可以将rdd的partiton变多
一个很经典的场景, 使用Spark SQL从hive中查询数据时 Spark SQL会根据hive对应的hdfs文件的block数量来决定加载出来的数据rdd 中有多少个partition,这里的partition数量, 是我们根本无法
设置的
有时候可能自动设置的partition数量过少, 导致我们后面的算子的运行特别慢 此时就可以在Spark SQL加载hive数据到rdd之后, 立即使用repartition算子, 将rdd的partition数量变多
def repartition: Unit ={ val conf=new SparkConf().setAppName("cartesian").setMaster("local") val sc=new SparkContext(conf) val a=sc.parallelize(Array("liu","zhao","wang","li","lll","aa"),3) val result=a.coalesce(2)//通过 coalesce减少分区
// val result=a.repartition(4) 通过repartition增加 或者减少分区数 result.mapPartitionsWithIndex((x,y)=>{ val arr=ArrayBuffer[String]() while(y.hasNext){ val info=x+" "+y.next() arr+=info } arr.iterator }).foreach(x=>println(x)) }
补充:1、map:一次处理分区中的一条数据
mapPartitions:一次处理分区中的所有数据
mapPartitionsWithIndex:一次处理分区中的所有数据 ,并且返回分区的索引,索引从0开始
注意:如果RDD分区中的数据体量比较大,用mapPartitions或者mapPartitionsWithIndex进行计算,有可能出现内存溢出(OOM)
如果RDD分区数据体量比较小,此时为了提高数据计算的效率,可以使用mapPartitions或mapPartitionsWithIndex进行计算