RDD的一些api的用法

RDD API 分为Actor类型与Transformation类型

Transformation：延迟加载，并不会直接计算结果，而是记住这些应用到基础数据集上的转换动作。只有在要求返回结果给Driver的动作时（也可以说到actor方法），这些转换才会真正运行，这让spark更加有效率地运行

常用的transformation api

map(func)，遍历元素通过func函数生成新的元素
filter(func) ，遍历元素通过func函数返回为true的元素
flatMap(func) ， 同map，不过通过func函数后生成的是0到多个新元素，func返回的是序列
mapPartitions(func) ， 类似于map，但独立地在RDD的每一个分片上运行，因此在类型为T的RDD上运行时，func的函数类型必须是Iterator[T] => Iterator[U]
mapPartitionsWithIndex(func) ， 类似于mapPartitions，但func带有一个整数参数表示分片的索引值，因此在类型为T的RDD上运行时，func的函数类型必须是
(Int, Interator[T]) => Iterator[U]
sample(withReplacement, fraction, seed) ， 根据fraction指定的比例对数据进行采样，可以选择是否使用随机数进行替换，seed用于指定随机数生成器种子
union(otherDataset) ， 对源RDD和参数RDD求并集后返回一个新的RDD
intersection(otherDataset) ， 对源RDD和参数RDD求交集后返回一个新的RDD
distinct([numTasks])) ， 对源RDD进行去重后返回一个新的RDD
groupByKey([numTasks])  ，在一个(K,V)的RDD上调用，返回一个(K, Iterator[V])的RDD
reduceByKey(func, [numTasks])，在一个(K,V)的RDD上调用，返回一个(K,V)的RDD，使用指定的reduce函数，将相同key的值聚合到一起，与groupByKey类似，reduce任务的个数可以通过第二个可选的参数来设置
aggregateByKey(zeroValue)(seqOp, combOp, [numTasks]) 
sortByKey([ascending], [numTasks])，在一个(K,V)的RDD上调用，K必须实现Ordered接口，返回一个按照key进行排序的(K,V)的RDD
sortBy(func,[ascending], [numTasks])，与sortByKey类似，但是更灵活
join(otherDataset, [numTasks])，在类型为(K,V)和(K,W)的RDD上调用，返回一个相同key对应的所有元素对在一起的(K,(V,W))的RDD
cogroup(otherDataset, [numTasks])，在类型为(K,V)和(K,W)的RDD上调用，返回一个(K,(Iterable<V>,Iterable<W>))类型的RDD
cartesian(otherDataset)，笛卡尔积
pipe(command, [envVars])
coalesce(numPartitions) 
repartition(numPartitions)
repartitionAndSortWithinPartitions(partitioner)

Actor:

常用的actor api

reduce(func)    通过func函数聚集RDD中的所有元素，这个功能必须是可交换且可并联的
collect()   在驱动程序中，以数组的形式返回数据集的所有元素
count() 返回RDD的元素个数
first() 返回RDD的第一个元素（类似于take(1)）
take(n) 返回一个由数据集的前n个元素组成的数组
takeSample(withReplacement,num, [seed]) 返回一个数组，该数组由从数据集中随机采样的num个元素组成，可以选择是否用随机数替换不足的部分，seed用于指定随机数生成器种子
takeOrdered(n, [ordering])  
saveAsTextFile(path)    将数据集的元素以textfile的形式保存到HDFS文件系统或者其他支持的文件系统，对于每个元素，Spark将会调用toString方法，将它装换为文件中的文本
saveAsSequenceFile(path)    将数据集中的元素以Hadoop sequencefile的格式保存到指定的目录下，可以使HDFS或者其他Hadoop支持的文件系统。
saveAsObjectFile(path)  
countByKey()    针对(K,V)类型的RDD，返回一个(K,Int)的map，表示每一个key对应的元素个数。
foreach(func)   在数据集的每一个元素上，运行函数func进行更新。

其它API

rdd.map(_*2).sortby(x=>x,true) 排序
rdd.groupByKey().mapValue(_.sum)   统计出现次数     将所有数据分区，再统计，有大量IO
rdd.reduceByKey(_+_)    同上效果一样   先分区聚合，再整体聚合  。（这个方法效果好，使用这种）
mappartitions 循环每个分区元素
mappartitionswithIndex  循环每个分区元素，还可以有分区index

rdd.aggregate(0)(_+_,_+_)聚合，给定初始参数0，每个分区相加，聚合相加，前面的参数会进行分区数+1次聚合
rdd.aggregate(0)(math.max(_,_),_+_) 取出每个分区最大数，然后得到他们的和
rdd.aggregateByKey(0)(_+_,_+_) 与reducebykey效果相同，wordcount


checkpoint：设置检查点，重要的数据的检查
sc.setCheckpointDir("") //设置的备份目录，最好设置到hdfs中（避免丢失）
val rdd =sc.textFile("") //设置读取数据返回rdd
rdd.checkpoint 对这rdd设置检查点
rdd.ischeckpointed  返回boolean  查看是否保存到检查点
rdd.count 由于是懒加载，所以调一下count来提交了任务
rdd.ischeckpointed  再次查看是否保存
rdd.getCheckpointFile 检查数据保存到哪里了

repartition ,coalesce 重新分区
val rdd1=sc.parallelize(1 to 10,10) 这会分10个分区
rdd1.partitions.length  检查rdd1的分区数
val rdd2=rdd1.repaartition(2)  将rdd1的数据给rdd2 ，然后rdd2重新分区 2个
val rdd3=rdd1.coalesce(2,flase) 这也同上重新分区2个，第二个参数是-是否shuffle（flase，那么分区数只能变少，true，分区数可以变多）
val rdd4 =rdd1.partitionBy(new HashPartitioner(2)) 里面传的参数是一个分区器，可以自定义

collectAsMap //转化为map
val rdd=sc.parallelize(List(("a",1),("b",2)))
rdd.collectAsMap  //就变成  Map(b->2,a->1)

combineByKey:  传入三个函数，第一个循环出的数，第二个分区聚合，第三个全局聚合
val rdd1=sc.textFile("").flatMap(_.split("")).map((_,1))   //以下是wordcount
val rdd2 =rdd1.combineBykey(x=>x,(a:Int,b:Int)=>a+b,(m:Int,n:Int) =>m+n)  
//以下是combineByKey的第二例子
val rdd4=sc.parallelize(List("dog","cat","mouse","salmon","rabit","wolf","bear","bee"))
val rdd5=sc.parallelize(List(1,2,1,1,4,2,1,1,2,1))
val rdd6=rdd5.zip(rdd4)  这里形成了数字在前的元祖集合
val rdd7=rdd6.combineByKey(List(_),(x:List[String],y:String)=>x:+y,(m:List[String],n:List[String])=>m++n).collect   Array((1,List(dog,cat..)),(2,List(mouse,..)) 也就是将1个和2个的动物分组

countBykey 统计相同key出现的次数
val rdd=sc.parallelize(List(("a",1),("b",2)))
rdd.countByKey
rdd.reduceBykey(_+_) 这个会将值相加
rdd.countbyValue  相同整个元素出现的次数

filteByRange 过滤范围，是按字典序
val rdd=sc.parallelize(List(("a",1),("b",2),("e",3)))
val rdd2=rdd.filterByRange("b","f")

flatMapValues 取出value操作，然后压平
val rdd=sc.parallelize(List(("a","1 2"),("b","3 4")))
val rdd2=rdd.flatValues(_.split(" ")).collect  Array((a,1),(a,2),(b,3),(b,4))

foldByKey  以key来折叠  也可以用来wordcount
Array((3,dog),(4,wolf),(3,cat),(4,bear)) 
rdd.foldByKey("")(_+_) 结果是 Array((4,wollfbear),(3,dogcat))

foreachPartition  每个分区元素遍历 后面的括号里传函数

keyBy  以参数为key生成元祖   
val rdd=sc.parallelize(List("a","ab"))
rdd.keyBy(_.length)   结果Array((1,a),(2,ab))   相当于map(x=>(x.length,x))

keys  map的集合中直接获取key的集合  元祖元素是2个以上不行
values map的集合中获取value的集合   元祖元素是2个以上不行