Spark常用函数讲解之键值RDD转换

摘要:

RDD:弹性分布式数据集,是一种特殊集合 ‚ 支持多种来源 ‚ 有容错机制 ‚ 可以被缓存 ‚ 支持并行操作,一个RDD代表一个分区里的数据集
RDD有两种操作算子:

        Transformation(转换):Transformation属于延迟计算,当一个RDD转换成另一个RDD时并没有立即进行转换,仅仅是记住       了数据集的逻辑操作
         Ation(执行):触发Spark作业的运行,真正触发转换算子的计算
 
本系列主要讲解Spark中常用的函数操作:
         1.RDD基本转换
         2.键-值RDD转换
         3.Action操作篇
 
本节所讲函数
1. mapValus
2. flatMapValues
3.comineByKey
5.reduceByKey
6.groupByKey
7.sortByKey
8.cogroup
9.join
10.LeftOutJoin
11.RightOutJoin
 
1.mapValus(fun):对[K,V]型数据中的V值map操作
(例1):对每个的的年龄加2
1
2
3
4
5
6
7
8
9
10
object MapValues {
   def main(args: Array[String]) {
     val conf =  new  SparkConf().setMaster( "local" ).setAppName( "map" )
     val sc =  new  SparkContext(conf)
     val list = List(( "mobin" , 22 ),( "kpop" , 20 ),( "lufei" , 23 ))
     val rdd = sc.parallelize(list)
     val mapValuesRDD = rdd.mapValues(_+ 2 )
     mapValuesRDD.foreach(println)
   }
}
输出:
(mobin,24)
(kpop,22)
(lufei,25)
(RDD依赖图:红色块表示一个RDD区,黑色块表示该分区集合,下同)
 
 
2.flatMapValues(fun):对[K,V]型数据中的V值flatmap操作
(例2):
1
2
3
4
//省略<br>val list = List(("mobin",22),("kpop",20),("lufei",23))
val rdd = sc.parallelize(list)
val mapValuesRDD = rdd.flatMapValues(x => Seq(x, "male" ))
mapValuesRDD.foreach(println)
输出:
(mobin,22)
(mobin,male)
(kpop,20)
(kpop,male)
(lufei,23)
(lufei,male)
如果是mapValues会输出:
(mobin,List(22, male))
(kpop,List(20, male))
(lufei,List(23, male))
(RDD依赖图)
 
 
3.comineByKey(createCombiner,mergeValue,mergeCombiners,partitioner,mapSideCombine)
 
   comineByKey(createCombiner,mergeValue,mergeCombiners,numPartitions)
 
   comineByKey(createCombiner,mergeValue,mergeCombiners)
 
createCombiner:在第一次遇到Key时创建组合器函数,将RDD数据集中的V类型值转换C类型值(V => C),
如例3:
mergeValue合并值函数,再次遇到相同的Key时,将createCombiner道理的C类型值与这次传入的V类型值合并成一个C类型值(C,V)=>C,
如例3:
mergeCombiners:合并组合器函数,将C类型值两两合并成一个C类型值
如例3:
 
partitioner:使用已有的或自定义的分区函数,默认是HashPartitioner
 
mapSideCombine:是否在map端进行Combine操作,默认为true
 
注意前三个函数的参数类型要对应;第一次遇到Key时调用createCombiner,再次遇到相同的Key时调用mergeValue合并值
 
(例3):统计男性和女生的个数,并以(性别,(名字,名字....),个数)的形式输出
1
2
3
4
5
6
7
8
9
10
11
12
13
14
object CombineByKey {
   def main(args: Array[String]) {
     val conf =  new  SparkConf().setMaster( "local" ).setAppName( "combinByKey" )
     val sc =  new  SparkContext(conf)
     val people = List(( "male" "Mobin" ), ( "male" "Kpop" ), ( "female" "Lucy" ), ( "male" "Lufei" ), ( "female" "Amy" ))
     val rdd = sc.parallelize(people)
     val combinByKeyRDD = rdd.combineByKey(
       (x: String) => (List(x),  1 ),
       (peo: (List[String], Int), x : String) => (x :: peo._1, peo._2 +  1 ),
       (sex1: (List[String], Int), sex2: (List[String], Int)) => (sex1._1 ::: sex2._1, sex1._2 + sex2._2))
     combinByKeyRDD.foreach(println)
     sc.stop()
   }
}
输出:
(male,(List(Lufei, Kpop, Mobin),3))
(female,(List(Amy, Lucy),2))
过程分解:
复制代码
Partition1:
K="male"  -->  ("male","Mobin")  --> createCombiner("Mobin") =>  peo1 = (  List("Mobin") , 1 )
K="male"  -->  ("male","Kpop")  --> mergeValue(peo1,"Kpop") =>  peo2 = (  "Kpop"  ::  peo1_1 , 1 + 1 )    //Key相同调用mergeValue函数对值进行合并
K="female"  -->  ("female","Lucy")  --> createCombiner("Lucy") =>  peo3 = (  List("Lucy") , 1 )
 
Partition2:
K="male"  -->  ("male","Lufei")  --> createCombiner("Lufei") =>  peo4 = (  List("Lufei") , 1 )
K="female"  -->  ("female","Amy")  --> createCombiner("Amy") =>  peo5 = (  List("Amy") , 1 )
 
Merger Partition:
K="male" --> mergeCombiners(peo2,peo4) => (List(Lufei,Kpop,Mobin))
K="female" --> mergeCombiners(peo3,peo5) => (List(Amy,Lucy))
复制代码
(RDD依赖图)
 
4.foldByKey(zeroValue)(func)
 
  foldByKey(zeroValue,partitioner)(func)
 
  foldByKey(zeroValue,numPartitiones)(func)
 
foldByKey函数是通过调用CombineByKey函数实现的
 
zeroVale:对V进行初始化,实际上是通过CombineByKey的createCombiner实现的  V =>  (zeroValue,V),再通过func函数映射成新的值,即func(zeroValue,V),如例4可看作对每个V先进行  V=> 2 + V  
 
func: Value将通过func函数按Key值进行合并(实际上是通过CombineByKey的mergeValue,mergeCombiners函数实现的,只不过在这里,这两个函数是相同的)
例4:
1
2
3
4
5
//省略
     val people = List(( "Mobin" 2 ), ( "Mobin" 1 ), ( "Lucy" 2 ), ( "Amy" 1 ), ( "Lucy" 3 ))
     val rdd = sc.parallelize(people)
     val foldByKeyRDD = rdd.foldByKey( 2 )(_+_)
     foldByKeyRDD.foreach(println)
输出:
(Amy,2)
(Mobin,4)
(Lucy,6)
先对每个V都加2,再对相同Key的value值相加。
 
 
5.reduceByKey(func,numPartitions):按Key进行分组,使用给定的func函数聚合value值, numPartitions设置分区数,提高作业并行度
例5
1
2
3
4
5
6
//省略
val arr = List(( "A" , 3 ),( "A" , 2 ),( "B" , 1 ),( "B" , 3 ))
val rdd = sc.parallelize(arr)
val reduceByKeyRDD = rdd.reduceByKey(_ +_)
reduceByKeyRDD.foreach(println)
sc.stop
输出:
(A,5)
(A,4)
(RDD依赖图)
 
6.groupByKey(numPartitions):按Key进行分组,返回[K,Iterable[V]],numPartitions设置分区数,提高作业并行度
例6:
1
2
3
4
5
6
//省略
val arr = List(( "A" , 1 ),( "B" , 2 ),( "A" , 2 ),( "B" , 3 ))
val rdd = sc.parallelize(arr)
val groupByKeyRDD = rdd.groupByKey()
groupByKeyRDD.foreach(println)
sc.stop
输出:
(B,CompactBuffer(2, 3))
(A,CompactBuffer(1, 2))
 
以上foldByKey,reduceByKey,groupByKey函数最终都是通过调用combineByKey函数实现的
 
7.sortByKey(accending,numPartitions):返回以Key排序的(K,V)键值对组成的RDD,accending为true时表示升序,为false时表示降序,numPartitions设置分区数,提高作业并行度
例7:
1
2
3
4
5
6
//省略sc
val arr = List(( "A" , 1 ),( "B" , 2 ),( "A" , 2 ),( "B" , 3 ))
val rdd = sc.parallelize(arr)
val sortByKeyRDD = rdd.sortByKey()
sortByKeyRDD.foreach(println)
sc.stop
输出:
(A,1)
(A,2)
(B,2)
(B,3)
 
8.cogroup(otherDataSet,numPartitions):对两个RDD(如:(K,V)和(K,W))相同Key的元素先分别做聚合,最后返回(K,Iterator<V>,Iterator<W>)形式的RDD,numPartitions设置分区数,提高作业并行度
例8:
1
2
3
4
5
6
7
8
//省略
val arr = List(( "A" 1 ), ( "B" 2 ), ( "A" 2 ), ( "B" 3 ))
val arr1 = List(( "A" "A1" ), ( "B" "B1" ), ( "A" "A2" ), ( "B" "B2" ))
val rdd1 = sc.parallelize(arr,  3 )
val rdd2 = sc.parallelize(arr1,  3 )
val groupByKeyRDD = rdd1.cogroup(rdd2)
groupByKeyRDD.foreach(println)
sc.stop
输出:
(B,(CompactBuffer(2, 3),CompactBuffer(B1, B2)))
(A,(CompactBuffer(1, 2),CompactBuffer(A1, A2)))
(RDD依赖图)
 
 
9.join(otherDataSet,numPartitions):对两个RDD先进行cogroup操作形成新的RDD,再对每个Key下的元素进行笛卡尔积,numPartitions设置分区数,提高作业并行度
例9
1
2
3
4
5
6
7
//省略
val arr = List(( "A" 1 ), ( "B" 2 ), ( "A" 2 ), ( "B" 3 ))
val arr1 = List(( "A" "A1" ), ( "B" "B1" ), ( "A" "A2" ), ( "B" "B2" ))
val rdd = sc.parallelize(arr,  3 )
val rdd1 = sc.parallelize(arr1,  3 )
val groupByKeyRDD = rdd.join(rdd1)
groupByKeyRDD.foreach(println)
输出:
复制代码
(B,(2,B1))
(B,(2,B2))
(B,(3,B1))
(B,(3,B2))
 
(A,(1,A1))
(A,(1,A2))
(A,(2,A1))
(A,(2,A2)
复制代码
(RDD依赖图)
 
 
10.LeftOutJoin(otherDataSet,numPartitions):左外连接,包含左RDD的所有数据,如果右边没有与之匹配的用None表示,numPartitions设置分区数,提高作业并行度
例10:
1
2
3
4
5
6
7
8
//省略
val arr = List(( "A" 1 ), ( "B" 2 ), ( "A" 2 ), ( "B" 3 ),( "C" , 1 ))
val arr1 = List(( "A" "A1" ), ( "B" "B1" ), ( "A" "A2" ), ( "B" "B2" ))
val rdd = sc.parallelize(arr,  3 )
val rdd1 = sc.parallelize(arr1,  3 )
val leftOutJoinRDD = rdd.leftOuterJoin(rdd1)
leftOutJoinRDD .foreach(println)
sc.stop
输出:
复制代码
(B,(2,Some(B1)))
(B,(2,Some(B2)))
(B,(3,Some(B1)))
(B,(3,Some(B2)))
 
(C,(1,None))
 
(A,(1,Some(A1)))
(A,(1,Some(A2)))
(A,(2,Some(A1)))
(A,(2,Some(A2)))
复制代码
 
11.RightOutJoin(otherDataSet, numPartitions):右外连接,包含右RDD的所有数据,如果左边没有与之匹配的用None表示,numPartitions设置分区数,提高作业并行度
例11:
1
2
3
4
5
6
7
8
//省略
val arr = List(( "A" 1 ), ( "B" 2 ), ( "A" 2 ), ( "B" 3 ))
val arr1 = List(( "A" "A1" ), ( "B" "B1" ), ( "A" "A2" ), ( "B" "B2" ),( "C" , "C1" ))
val rdd = sc.parallelize(arr,  3 )
val rdd1 = sc.parallelize(arr1,  3 )
val rightOutJoinRDD = rdd.rightOuterJoin(rdd1)
rightOutJoinRDD.foreach(println)
sc.stop
输出:
复制代码
(B,(Some(2),B1))
(B,(Some(2),B2))
(B,(Some(3),B1))
(B,(Some(3),B2))
 
(C,(None,C1))
 
(A,(Some(1),A1))
(A,(Some(1),A2))
(A,(Some(2),A1))
(A,(Some(2),A2))
复制代码

 

以上例子源码地址:https://github.com/Mobin-F/SparkExample/tree/master/src/main/scala/com/mobin/SparkRDDFun/TransFormation/RDDBase

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: Spark中的RDD(Resilient Distributed Datasets)是一种分布式的数据结构,它可以被分割成多个分区,每个分区可以在不同的节点上进行计算。RDD提供了一系列的转换和操作函数,可以对RDD进行各种操作。 RDD转换函数包括map、filter、flatMap、union、distinct、groupByKey、reduceByKey、sortByKey等。这些函数可以对RDD进行转换操作,生成新的RDDRDD操作函数包括count、collect、reduce、take、foreach等。这些函数可以对RDD进行操作,返回结果或者将结果输出到外部系统。 在使用RDD时,需要注意一些问题,如RDD的惰性计算、RDD的持久化、RDD的分区等。同时,还需要根据实际情况选择合适的RDD转换和操作函数,以达到最优的计算效果。 总之,Spark中的RDD转换和操作函数是非常重要的,掌握它们可以帮助我们更好地使用Spark进行分布式计算。 ### 回答2: Spark是一个基于内存计算的分布式计算框架,可以实现大规模数据集的快速处理。在Spark中,RDD(弹性分布式数据集)是数据处理的核心概念,它是一种可以分区、并行计算和容错的不可变数据结构。而Spark中的函数式编程模型则将RDD转换与操作都看做是函数的调用,从而简洁明了,易于理解和操作。 在Spark中,解决一个具体问题通常涉及一系列RDD转换和操作。RDD转换包括对原有RDD进行过滤、映射、聚合等处理,得到新的RDD;操作则是对新的RDD进行输出、保存、统计、排序等操作。以下介绍几种常见的RDD转换和操作函数。 1. map函数 map函数是一种转换函数,它可以将一个RDD中每个元素通过一个用户定义的函数映射到另一个RDD中,并得到新的RDD。例如,将一个整型RDD中的每个元素都乘以2后得到一个新的整型RDD: ``` val rdd1 = sc.parallelize(Array(1, 2, 3, 4)) val rdd2 = rdd1.map(x => x*2) ``` 2. filter函数 filter函数也是一种转换函数,它可以根据用户定义的条件过滤一个RDD中的元素,并得到一个新的RDD。例如,将一个字符串RDD中长度大于5的元素过滤出来得到一个新的字符串RDD: ``` val rdd1 = sc.parallelize(Array("hello", "world", "spark", "rdd")) val rdd2 = rdd1.filter(x => x.length > 5) ``` 3. reduce函数 reduce函数是一种操作函数,它可以将一个RDD中的元素按照用户定义的函数进行聚合并得到一个结果。例如,将一个整型RDD中的所有元素相加得到一个整数结果: ``` val rdd1 = sc.parallelize(Array(1, 2, 3, 4)) val result = rdd1.reduce((x, y) => x + y) ``` 4. collect函数 collect函数也是一种操作函数,它可以将一个RDD中的所有元素收集起来并输出到Driver端。然而,使用collect函数需要注意RDD的大小,如果RDD很大,就可能会出现内存溢出的情况。例如,将一个整型RDD中的所有元素收集起来并输出到屏幕: ``` val rdd1 = sc.parallelize(Array(1, 2, 3, 4)) val result = rdd1.collect() result.foreach(println) ``` 5. saveAsTextFile函数 saveAsTextFile函数也是一种操作函数,它可以将一个RDD中的所有元素保存到指定的文本文件中。例如,将一个字符串RDD中的所有元素保存到hdfs的一个文本文件中: ``` val rdd1 = sc.parallelize(Array("hello", "world", "spark", "rdd")) rdd1.saveAsTextFile("hdfs://localhost:8020/user/abc/output") ``` 总之,Spark中的RDD转换和操作函数具有弹性、高效、简单等特点,能够满足各种大规模数据处理需求。需要特别注意的是,Spark中的函数式编程模型是基于JVM的,因此要充分利用内存和CPU资源,需要对集群配置和调优进行一定的优化和测试。 ### 回答3: Spark中的RDD(Resilient Distributed Datasets)是分布式的弹性数据集,它可以在大规模集群上并行化地计算,并且提供了一系列的转换和操作函数。其中,Spark提供的Spark函数简单易用,具有高效的数据处理能力,可以帮助开发者快速开发分布式应用程序。 RDD转换函数是将一个RDD转换成另一个RDD函数转换后的RDD通常包含了数据处理、筛选和过滤后的新数据集,可以用来接着进行后续的计算。 例如,map函数可以将RDD中的每个元素应用一个函数,然后返回一个新的转换过的RDD: ``` val originalData = sc.parallelize(List(1, 2, 3, 4, 5)) val mappedData = originalData.map(x => x * 2) ``` 这里,map函数将原始数据中的每个元素都乘上了2,返回了一个新的RDD。 除了map函数, 还有flatMap、filter、groupBy等常用转换函数,都可以帮助我们对RDD做出各种各样的数据处理和转换RDD操作函数则是对RDD进行真正的计算操作,例如reduce、count、collect等函数,这些函数会触发Spark的分布式计算引擎执行真正的计算任务。 比如,reduce函数可以将RDD中的所有元素进行聚合,返回一个单一的结果: ``` val originalData = sc.parallelize(List(1, 2, 3, 4, 5)) val reducedData = originalData.reduce(_ + _) ``` 这里,reduce函数将原始数据中的所有元素进行相加操作,返回了一个整数类型的结果。 Spark提供的操作函数非常丰富,从基本的聚合、排序、统计操作,到高级的机器学习和图形处理等操作,开发者可以根据不同的业务需求灵活选择使用。 总之,Spark中的RDD转换和操作函数是分布式数据处理的核心之一,通过这些函数,开发者能够方便地对海量数据进行分布式的计算和处理。同时,Spark也提供了丰富的API和工具,便于开发者进行高效的Spark应用程序开发。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值