Spark 基础操作

Spark 操作

创建操作(Creation Operation)

用于RDD创建工作。RDD创建只有两种方法，一种是来自于内存集合和外部存储系统，另一种是通过转换操作生成的RDD

转换操作(Transformation Operation)

将RDD通过一定的操作变成新的RDD，比如HadoopRDD可以使用map操作变换为MappedRDD

RDD的转换操作是惰性操作，它只是定义了一个新的RDDs,并没有立即执行

控制操作(Control Operation)

进行RDD持久化，可以让RDD按不同的存储策略保存在磁盘或内存中，比如cache接口默认将RDD缓存在内存中

行动操作(Action Operation)

能够触发Spark运行的操作，例如，对RDD进行collect就是行动操作

Spark中行动操作分为两类，一类的操作结果变成Scala集合或者变量，另一类将RDD保存到外部文件系统或者数据库中

创建操作

parallelize $T$ (seq:Seq $T$ , numSlices:Int)

parallelize 在一个已经存在的Scala集合上创建(一个Seq对象)。集合的对象将会被复制，创建出一个可以被并行操作的分布式数据集

makeRDD $T$ (seq:Seq $(T, Seq\[String$ )]):RDD $T$

并行化集合创建操作

基础转换操作

map $U$ (f:(T) => U):RDD $U$

map操作是对RDD中的每个元素都执行一个指定的函数来产生一个新的RDD，任何原RDD中的元素在新RDD中都有且只有一个元素与之对应

distinct():RDD $(T)$ /distinct(nPartitions):RDD $(T)$

distinct操作是去除RDD重复的元素，返回所有元素不重复RDD

flatMap $U$ (f:(T) => TraversableOnce $U$ ):RDD $U$

flatMap操作与map类似，区别是原RDD中的每个元素经过map处理后只能生成一个元素，而在flatMap操作中原RDD中的每个元素可生成一个或多个元素来构建RDD

coalesce(numPartitions:Int,shuffle:Boolean = false):RDD $T$

coalesce操作使用HashPartitioner进行重分区，第一个参数为重分区的数目，第二个是否进行shuffle，默认情况为false

repartition(numPartitions:Int):RDD $T$

repartition操作是coalesce函数第二个参数为true的实现

randomSplit(weights:Array $Double$ , send:Long):Array $RDD\[T$ ]

randomSplit操作是根据weights权重将一个RDD分隔为多个RDD

glom():RDD $Array\[T$ ]

glom操作则是RDD中每一个分区所有类型为T的数据转变成元素为T的数组 $Array\[T$ ]

union(other:RDD $T$ ):RDD $T$

union操作是将两个RDD合并，返回两个RDD的并集，返回元素不去重

intersection(other:RDD $T$ ):RDD $T$

intersection操作类似SQL中的inner join操作，返回两个RDD交集，返回元素去重

subtract(other:RDD $T$ ):RDD $T$

subtract 返回在RDD中出现，且不在otherRDD中出现的元素

mapPartitions $U$ (f:(Iter), preserversPartitons:Boolean)

mapPartitions操作和map操作类似，只不过映射的参数由RDD中的每一个元素变成了RDD中每一个分区的迭代器

其中preserversPartitons表示是否保留父RDD的partitioner分区信息

如果在映射的过程中需要频繁创建额外的对象，使用mapPartitions操作要比map操作高效得多

比如，将RDD中的所有数据通过JDBC连接写入数据库，如果使用map函数，可能要为每一个元素都创建一个connection，这样开销很大

如果使用mapPartitions，那么只需要针对每一个分区建立一个connection

mapPartitionsWithIndex $U$ (f:(Iter), preserversPartitons:Boolean):RDD $U$

mapPartitionsWithIndex 操作作用类似于mapPartitions，只是输入参数多一个了分区索引

zip $U$ (other:RDD $U$ ):RDD $(T,U)$

zip操作用于将两个RDD组合成Key/Value形式的RDD，这里默认两个RDD的partition数量以及元素数量相同，否则会抛出异常

zipPartitions $B,V$ (rdd2:RDD $B$ )

zipPartitions 操作将多个RDD按照partition组合成新的RDD，该操作需要组合的RDD具有相同的分区数，但对于每个分区内的元素数量没有要求

zipWithIndex():RDD $(T,Long)$

zipWithIndex操作将RDD中的元素和这个元素在RDD中的ID(索引号)组合成键/值对

zipWithUniqueId():RDD $(T,Long)$

zipWithUniqueId 操作将RDD中的元素和一个唯一ID组合成键/值对，该唯一ID生成算法如下:

每个分区中第一个元素的唯一ID值为: 该分区索引号
每个分区中第N个元素的唯一ID值为:(前一个元素的唯一ID值) + (该RDD总的分区数)

键值转换操作

partitionBy(partitioner: Partitioner):RDD $(K, V)$

partitionBy 操作根据partitioner函数生成新的ShuffleRDD

mapValues $U$ (f:(V) => U):RDD $(K, U)$

mapValues类似于map，只不过mapValues是针对 $K,V$ 中的V值进行map操作

flatMapValues $U$ (f:(V) => TraverableOnce $U$ ):RDD $(K,U)$

flatMapValues 相对flatMap, flatMapValues是针对 $K,V$ 中的V值进行flatMap操作

combineByKey $C$ (createCombiner:(V), mergeValue:(C, V), mergeCombiners)

combineByKey 操作用于将RDD $K,V$ 转换成RDD $K,C$ .这里V类型和C类型可以相同也可以不同

combineByKey 参数含义

createCombiner: 组合器函数，用于将V类型转换成C类型，输入参数为RDD $K,V$ 中的V，输出为C
mergeValue: 合并值函数，将一个C类型和一个V类型值合并成一个C类型，输入参数为(C,V),输出为C
mergeCombiners: 合并组合器函数，用于将两个C类型值合并成一个C类型，输入参数为(C,C)，输出为C
numPartitons: 结果RDD分区数，默认保持原有的分区数
partitioner: 分区函数，默认为HashPartitioner
mapSideCombine: 是否需要在Map端进行combine操作，类似于MapReduce中的combine,默认为true

foldByKey(zeroValue:V)(func:(V, V)=>V):RDD $(K,V)$

foldByKey 操作用于RDD $K, V$ 转换K将V做折叠、合并处理。其中参数zeroValue表示先根据映射函数将zeroValue应用于V

进行初始化V，再将映射函数应用于初始化后的V

reduceByKey(func:(V, V) => V):RDD $(K,V)$

reduceByKey操作用于将RDD $K,V$ 中每个K对应的V值根据映射函数来运算，其中参数numPartitions用于指定分区数，参数partitioner用于指定分区函数

reduceByLocally(func:(V, V) => V):Map $K,V$

reduceByLocally 和 reduceByKey 功能类似，不同的是，reduceByLocally运算结果映射到一个Map $K,V$ 中，而不是RDD $K,V$

groupByKey():RDD $(K, Iterable\[V$ )]

groupByKey 操作用于将RDD $K,V$ 中每个K对应的V值合并到一个集合Iterable $V$ 中

cogroup $W$ (other:RDD $(K,V)$ ):RDD $(K,(Iterable\[V$ , Iterable $W$ ))]

cogroup 相当于SQL中的全外关联，返回左右RDD中的记录，关联不上的为空

可传入的参数有1~3个RDD，参数numPartitons用于指定分区数，参数partitioner用于指定分区函数

join、fullOuterJoin、leftOuterJoin、rightOuterJoin

join、fullOuterJoin、leftOuterJoin、rightOuterJoin 都是针对RDD $K,V$ 中K值相等的连接操作

分别对应内连接、全连接、左连接和右连接。这些操作都调用cogroup进行实现，subtractByKey和基本操作subtract,只是subtractByKey针对的是键值操作

其中参数numPartions用于指定分区数，参数partitioner用于指定分区函数

控制操作

cache():RDD $T$

缓存

persist():RDD\[\]

persit(level:StorageLevel):RDD $T$

行动操作

集合标量行动操作

first(): T 表示返回RDD中的第一个元素，不排序

count(): Long 表示返回RDD中的元素个数

reduce(f:(T, T) => T):T

根据映射函数f，对RDD中的元素进行二元计算

collect(): Array $T$

表示将RDD转换成数组

take(num: Int): Array $T$

表示获取RDD中从0到num-1下标的元素，不排序

top(num: Int): Array $T$

表示从RDD中，按照默认(降序)或者指定的排序规则，返回前num个元素

takeOrdered(num: Int): Array $T$

和top类似，只不过以和top相反的顺序返回元素

aggregate $U$ (zeroValue: U)(seqOp: (U, T) => U, combOp: (U,U) => U)

用户聚合RDD中的元素，先使用seqOp将RDD中每个分区中的T类型聚合成U类型

再使用combOp将之前每个分区聚合后的U类型聚合成U类型，特别注意seqOp和combOp都会使用zeroValue的值，zeroValue的类型的为U

fold(zeroValue: T)(op: (T, T)=>T): Taggregate

fold是aggregate的简化，将aggregate中的seqOp和combOp使用同一个函数op

lookup(key: K): Seq $V$

lookup用于(K,V)类型的RDD，指定K值，返回RDD中该K对应的所有V值

countByKey(): Map $K, Long$

countByKey 统计RDD $K, V$ 中每个K的数量

foreach(f:(T) => Unit): Unit

foreach 遍历RDD，将函数f应用于每一个元素

要注意如果对RDD执行foreach，只会在Executor端有效，而并不是Driver端

foreachPartition(f:(Iterator $T$ ) => Unit): Unit

foreachPartition 和 foreach类似，只不过是对每一个分区使用f

sortBy $K$ (f:(T), ascending:Boolean, numPartitions):RDD $T$

sortBy根据给定的排序k函数将RDD中的元素进行排序

存储行动操作

saveAsTextFile(path: String): Util

saveAsTextFile 用于将RDD以文本文件的格式存储到文件系统中，codec参数可以指定压缩的类名

saveAsTextFile 用于将RDD以SequenceFile的文件格式保存到HDFS上

saveAsObjectFile(path: String): Util

saveAsObjectFile 用于将RDD中的元素序列化对象，存储到文件中，对于HDFS，默认采用SequenceFile保存

saveAsHadoop

saveAsHadoopFile 是将RDD存储在HDFS上的文件中

saveAsHadoopDataset(conf: JobConf): Unit

用于将RDD保存到除了HDFS的其他存储中，比如HBase

在JobConf中，通常需要关注或者设置5个参数: 文件的保存路径、key值的class类型、value值的class类型、RDD的输出格式以及压缩相关参数

Spark 基础操作

Spark 操作

创建操作(Creation Operation)

转换操作(Transformation Operation)

控制操作(Control Operation)

行动操作(Action Operation)

创建操作

parallelizeT(seq:SeqT, numSlices:Int)

makeRDDT(seq:Seq(T, Seq\[String)]):RDDT

基础转换操作

mapU(f:(T) => U):RDDU

distinct():RDD(T)/distinct(nPartitions):RDD(T)

flatMapU(f:(T) => TraversableOnceU):RDDU

coalesce(numPartitions:Int,shuffle:Boolean = false):RDDT

repartition(numPartitions:Int):RDDT

randomSplit(weights:ArrayDouble, send:Long):ArrayRDD\[T]

glom():RDDArray\[T]

union(other:RDDT):RDDT

intersection(other:RDDT):RDDT

subtract(other:RDDT):RDDT

mapPartitionsU(f:(Iter), preserversPartitons:Boolean)

mapPartitionsWithIndexU(f:(Iter), preserversPartitons:Boolean):RDDU

zipU(other:RDDU):RDD(T,U)

zipPartitionsB,V(rdd2:RDDB)

zipWithIndex():RDD(T,Long)

zipWithUniqueId():RDD(T,Long)