RDD算子

创建RDD的两种方法

1、由scala集合创建
val rdd1 = sc.parallelize(Array(1,2,3,4,5,6,7,8))
2、由外部存储系统的数据创建
val rdd2 = sc.textFile("hdfs://m1:9000/words.txt")

RDD的算子Transformation和Action

Transformation

所有转换都是延迟加载的，也就是说，它们并不会立即直接计算结果。相反的，它们只是记住这些应用到基础数据集（例如一个文件）上的转换动作。只有当发生一个要求返回结果给Driver的动作时，这些转换才会真正运行。这种设计让Spark更加有效率地运行。

常用的Transformation

map(func)：返回一个新的RDD，该RDD由每一个输入元素经过func函数转换后组成

val rdd1 = sc.parallelize(Array(1,2,3,4,5,6,7,8,9))
val rdd2 = rdd1.map(_+2)
rdd2.collect()

filter(func)：返回一个新的RDD，该RDD由经过func函数计算后返回值为true的元素组成

val rdd1 = sc.parallelize(Array(1,2,3,4,5,6,7,8,9))
val rdd2 = rdd1.filter(_ > 5)
rdd2.collect()

flatMap(func)：先map后flat, 类似于map，但是每一个输入元素可以被映射为0或多个输出元素（所以func应该返回一个序列，而不是单一元素）

val rdd1 = sc.parallelize(Array("hello tom", "hello jim"))
val rdd2 = rdd1.flatMap(_.split(" "))
rdd2.collect()

mapPartitions(func)：类似于map，但独立地在RDD的每一个分片上运行，因此在类型为T的RDD上运行时，func的函数类型必须是Iterator[T] => Iterator[U]

val rdd1 = sc.parallelize(Array(1,2,3,4,5,6,7,8,9))
val rdd2 = rdd1.repartition(2)
val rdd3 = rdd2.mapPartitions(it => it.map(_ * 2))
rdd3.collect()

mapPartitionsWithIndex(func)：类似于mapPartitions，但func带有一个整数参数表示分片的索引值，因此在类型为T的RDD上运行时，func的函数类型必须是(Int, Interator[T]) => Iterator[U]

val rdd1 = sc.parallelize(Array(1,2,3,4,5,6,7,8,9))
val rdd2 = rdd1.repartition(2)
val rdd3 = rdd2.mapPartitionsWithIndex((index, it) => {
println("分区索引" + index)
it
})
rdd3.collect()

sample(withReplacement, fraction, seed) ： 根据fraction指定的比例对数据进行采样，可以选择是否使用随机数进行替换，seed用于指定随机数生成器种子

val rdd1 = sc.parallelize(Array(1,2,3,4,5,6,7,8,9))
val rdd2 = rdd1.repartition(2)
val rdd3 = rdd2.sample(false, 0.5)
rdd3.collect()

union(otherDataset) ：对源RDD和参数RDD求并集后返回一个新的RDD

val rdd1 = sc.parallelize(Array(1,2,3,4,5,6,7,8,9))
val rdd2 = sc.parallelize(Array(1,2,3,4,5,6,7,8,9))
val rdd3 = rdd1.union(rdd2)
rdd3.collect()

intersection(otherDataset)： 对源RDD和参数RDD求交集后返回一个新的RDD

val rdd1 = sc.parallelize(Array(1,2,3,4,5,6))
val rdd2 = sc.parallelize(Array(4,5,6,7,8,9))
val rdd3 = rdd1.intersection(rdd2)
rdd3.collect()

distinct([numTasks]))：对源RDD进行去重后返回一个新的RDD

val rdd1 = sc.parallelize(Array(1,2,3,4,5,6,7,8,9,1,2,3,4,5,6,7,8,9))
val rdd2 = rdd1.distinct()
rdd2.collect()

groupByKey([numTasks])：在一个(K,V)的RDD上调用，返回一个(K, Iterator[V])的RDD

val rdd1 = sc.parallelize(Array(("hello", 1), ("hello", 1), ("tom", 1), ("kitty", 1)))
val rdd2 = rdd1.groupByKey()
rdd2.collect()

reduceByKey(func, [numTasks])： 在一个(K,V)的RDD上调用，返回一个(K,V)的RDD，使用指定的reduce函数，将相同key的值聚合到一起，与groupByKey类似，reduce任务的个数可以通过第二个可选的参数来设置

val rdd1 = sc.parallelize(Array(("hello", 1), ("hello", 1), ("tom", 1), ("kitty", 1)))
val rdd2 = rdd1.reduceByKey(_+_)
rdd2.collect()

aggregateByKey(zeroValue)(seqOp, combOp, [numTasks])

val rdd1 = sc.parallelize(Array((1, 3), (1, 2), (1, 4), (2, 3)), 2)

val rdd3 = rdd1.mapPartitionsWithIndex((index, it) => {
for (i <- it) {
print(index + ":" + i)

}
it
})

rdd3.collect()

//合并在不同partition中的值，a,b的数据类型为zeroValue的数据类型
def comb(a: String, b: String): String = {
println("comb: " + a + "	 " + b)
a + b
}
//合并在同一个partition中的值， a的数据类型为zeroValue的数据类型，b的数据类型为原value的数据类型
def seq(a: String, b: Int): String = {
println("seq: " + a + "	 " + b)
a + b
}

// zeroValue 中立值，定义返回value的类型，并参与每个分区key相同的一组的运算,
// seqOp 用来与partition中key相同的值进行合并
// comb 用来在不同partition中key相同的值进行合并
val rdd2 = rdd1.aggregateByKey("100")(seq,comb)

//打印输出
rdd2.collect()

/**
分析：
(1, 3), (1, 2), (1, 4), (2, 3) 分成两个分区：
第一个分区：(1,3),(1,2)
第二个分区：(1,4), (2,3)

seqOp分别与各个分区key相同的值进行运算

第一个分区为(1, 3), (1, 2)，所以运算为 "100" + 3 + 2 = 10032 -> (1, "10032")

第二个分区：
(1,4) "100" + 4 = 1004 -> (1, "1004")
(2,3) "100" + 3 = 1003 -> (2, "1003")

comb 用来对所有分区key相同数据进行合并，下载所有的数据为
(1, "10032")
(1, "1004")
(2, "1003")

因此合并结果如下
(1, "10032") (1, "1004") -> (1, "100321004")
(2, "1003") -> (2, "1003")
*/

 

sortByKey([ascending], [numTasks]) 在一个(K,V)的RDD上调用，K必须实现Ordered接口，返回一个按照key进行排序的(K,V)的RDD

val rdd1 = sc.parallelize(Array((1, 3), (1, 2), (1, 4), (2, 3)))
val rdd2 = rdd1.sortByKey()
rdd2.collect()

sortBy(func,[ascending], [numTasks]) 与sortByKey类似，但是更灵活

val rdd1 = sc.parallelize(Array((1, 3), (1, 2), (1, 4), (2, 3)))
val rdd2 = rdd1.sortBy(_._2)
rdd2.collect()

join(otherDataset, [numTasks]) 在类型为(K,V)和(K,W)的RDD上调用，返回一个相同key对应的所有元素对在一起的(K,(V,W))的RDD

val rdd1 = sc.parallelize(Array((1, 3), (1, 2), (1, 4), (2, 3)))
val rdd2 = sc.parallelize(Array((1, 3), (1, 2), (1, 4), (2, 3)))
val rdd3 = rdd1.join(rdd2)
rdd3.collect()

cogroup(otherDataset, [numTasks]) 在类型为(K,V)和(K,W)的RDD上调用，返回一个(K,(Iterable<V>,Iterable<W>))类型的RDD

cartesian(otherDataset) 笛卡尔积

val rdd1 = sc.parallelize(Array((1, 3), (1, 2), (1, 4), (2, 3)))
val rdd2 = sc.parallelize(Array((1, 3), (1, 2), (1, 4), (2, 3)))
val rdd3 = rdd1.cartesian(rdd2)
rdd3.collect()

coalesce(numPartitions)：减少分区到numPartitions，类似repartition

repartition(numPartitions):重新分区，numPartitions分区数据量

repartitionAndSortWithinPartitions(partitioner) ：对RDD按照指定的partitioner进行分区，并且每个分区按照key进行排序

Action

向spark集群提交任务，并计算结果

reduce(func) 通过func函数聚集RDD中的所有元素，这个功能必须是可交换且可并联的

val rdd1 = sc.parallelize(Array(1, 2,3,4,5,6,7))
val rs = rdd1.reduce(_+_)
println(rs)

collect() 在驱动程序中，以数组的形式返回数据集的所有元素

count() 返回RDD的元素个数

first() 返回RDD的第一个元素（类似于take(1)）

take(n) 返回一个由数据集的前n个元素组成的数组

takeSample(withReplacement,num, [seed])
返回一个数组，该数组由从数据集中随机采样的num个元素组成，可以选择是否用随机数替换不足的部分，seed用于指定随机数生成器种子

val rdd1 = sc.parallelize(Array(1, 2,3,4,5,6,7))
val rs = rdd1.takeSample(false, 5)
for (i <- rs) println(i)

takeOrdered(n, [ordering])：排序后去n个

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进行更新。