Spark学习摘记 —— RDD转化操作API归纳
本文参考
在阅读了《Spark快速大数据分析》动物书后，大概了解到了spark常用的api，不过书中并没有给予所有api具体的示例，而且现在spark的最新版本已经上升到了2.4.5，动物书中的spark版本还停留在1.2.0，所以就有了这篇文章，在最新的2.4.5版本下测试常用的api
由于spark的惰性计算特性，RDD只有在第一次行动操作中被用到时才会真正进行计算，因此我打算将文章内容分为"转化操作API"和"行动操作API"两部分，同时因为pair RDD（RDD中的元素是键值对）的部分api较为特殊，所以我打算单独再写一篇文章
本文仅介绍转化操作API，前5个api —— map()、flatMap()、filter()、distinct()、sample()是针对一个RDD的转化操作，后续的api —— union()、intersection()、subtract()、cartesion()是针对两个RDD的转化操作
RDD行动操作API归纳：https://www.cnblogs.com/kuluo/p/12550938.html
Pair RDD转化操作API归纳：https://www.cnblogs.com/kuluo/p/12558563.html
Pair RDD行动操作API归纳：https://www.cnblogs.com/kuluo/p/12567221.html
环境
idea + spark 2.4.5 + scala 2.11.12
RDD均通过SparkContext的parallelize()函数创建
map()函数
目的：
将函数应用于RDD中的每个元素，将返回值构成新的RDD
转化前后的RDD的元素类型可以不同（比如经典的WordCount示例中转化为了键值对元素）
代码：
val testList = List(1, 2, 3, 3)
val testRdd = sc.parallelize(testList)
testRdd.map(ele => ele * ele).foreach(ele => print(s"$ele "))
输出：
1 4 9 9
更高效的操作：
每个RDD被分为多个分区，这些分区在集群的不同节点上运行，可以使用mapPartitions()函数，将转化操作作用于每个分区的元素上，这种方法还可以为每个分区创建一个JDBC连接，而不是为每一个元素创建一个连接（此处不做示例）
mapPartitions()函数有两个参数，第一个参数接收一个函数，和map()函数相同，第二个参数为preservesPartitioning，默认值为false，仅当我们对pair RDD进行转化操作，并且没有修改键时设置为true
val testList = List(1, 2, 3, 3)
val testRdd = sc.parallelize(testList)
testRdd.mapPartitions(partition =>
partition.map(
ele => {
ele * ele
}
)).foreach(ele => print(s"$ele "))
flatMap()函数
目的：
将函数应用于RDD中的每个元素，将返回的迭代器的所有内容构成新的RDD，我们也常常说成是"压扁"
"压扁"这个词可能听上去不大好理解，我们提供给flatMap()的函数分别应用到RDD的那个元素上，不过返回的不是一个元素，而是一个返回值序列的迭代器，但输出的RDD不是由迭代器组成，得到的是一个包含各个迭代器可以访问的所有元素的RDD
转化前后的RDD的元素类型不变
代码：
val testList = List(1, 2, 3, 3)
val testRdd = sc.parallelize(testList)
testRdd.flatMap(ele => {
ele.to(5)
}).foreach(ele => print(s"$ele "))
我们也可以手动返回迭代器，这段代码也类似于
val testList = List(Range(1, 6), Range(2, 6), Range(3, 6), Range(3, 6))
val testRdd = sc.parallelize(testList)
testRdd.flatMap(_.iterator).foreach(ele => print(s"$ele "))
输出：
1 2 3 4 5 2 3 4 5 3 4 5 3 4 5
filter()函数
目的：
返回一个由传给filter()函数的元素组成的RDD，当函数返回值为true时，保留该元素，可以理解为 "被过滤"出来
代码：
val testList = List(1, 2, 3, 3)
val testRdd = sc.parallelize(testList)
testRdd.filter(ele => ele > 2).foreach(ele => print(s"$ele "))
输出：
3 3
更高效的操作：
通过过滤操作后，RDD中的元素减少，可以在filter()操作后执行coalesce()函数进行分区合并，第一个参数指定分区数，当指定的分区数大于当前RDD的分区数时不会进行合并，当前分区数不变（除非指定第二参数shuffle为true，默认为false），当指定的分区数小于当前的RDD的分区数时会进行合并，并且不会进行shuffle（尽量不要指定极端的情况，如指定合并后的分区数为1）
val testList = List(1, 2, 3, 3)
val testRdd = sc.parallelize(testList)
testRdd.filter(ele => ele > 2).coalesce(5).foreach(ele => print(s"$ele "))
distinct()函数
目的：
去重，因为会进行shuffle，所以不推荐此操作
代码：
val testList = List(1, 2, 3, 3)
val testRdd = sc.parallelize(testList)
testRdd.distinct().foreach(ele => print(s"$ele "))
输出：
1 2 3
sample()函数
目的：
对RDD进行采样
代码：
val testList = List(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
val testRdd = sc.parallelize(testList)
testRdd.sample(false, 0.9).foreach(ele => print(s"$ele "))
第一个参数withReplacement指定false时，第二个参数fraction必须为 [ 0 , 1 ] 之间，表示每个元素被选中的可能性
按照该示例，也有人将该函数理解为，从所有元素中抽取90%返回，但是在源码中我们可以看到：
without replacement: probability that each element is chosen; fraction must be [0, 1]
This is NOT guaranteed to provide exactly the fraction of the count of the given [[RDD]]
因此这种理解方式我认为是错误的
输出：
0 1 2 3 5 6 8 9（不一定）
疑点：
当第一个参数withReplacement指定true时，第二个参数fraction并不要求一定小于1，源码中注释为"with replacement: expected number of times each element is chosen; fraction must be greater than or equal to 0"
val testList = List(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
val testRdd = sc.parallelize(testList)
testRdd.sample(true, 3).foreach(ele => print(s"$ele "))
输出：0 0 1 1 1 1 2 2 2 3 3 3 3 4 4 4 4 4 5 5 5 5 5 5 6 6 7 7 8 9 9
目前不大理解是如何在采样的，希望各位看官大大能在评论区发表看法哈
unon()函数
目的：
相当于集合运算的并集，生成一个包含两个RDD中所有元素的RDD，要求两个RDD的元素类型相同
代码：
val testList1 = List(1, 2, 3)
val testList2 = List(3, 4, 5)
val testRdd1 = sc.parallelize(testList1)
val testRdd2 = sc.parallelize(testList2)
testRdd1.union(testRdd2).foreach(ele => print(s"$ele "))
输出：
1 2 3 3 4 5
intersection()函数
目的：
相当于集合运算的交集，求两个RDD共同的元素的RDD，要求两个RDD的元素类型相同
代码：
val testList1 = List(1, 2, 3)
val testList2 = List(3, 4, 5)
val testRdd1 = sc.parallelize(testList1)
val testRdd2 = sc.parallelize(testList2)
testRdd1.intersection(testRdd2).foreach(ele => print(s"$ele "))
输出：
3
subtract()函数
目的：
想当于集合运算的差集，移除一个RDD中的内容，要求两个RDD的元素类型相同
代码：
val testList1 = List(1, 2, 3)
val testList2 = List(3, 4, 5)
val testRdd1 = sc.parallelize(testList1)
val testRdd2 = sc.parallelize(testList2)
testRdd1.subtract(testRdd2).foreach(ele => print(s"$ele "))
输出：
1 2
cartesion()函数
目的：
与另一个RDD的笛卡尔积
代码：
val testList1 = List(1, 2, 3)
val testList2 = List('a', 'b', 'c')
val testRdd1 = sc.parallelize(testList1)
val testRdd2 = sc.parallelize(testList2)
testRdd1.cartesian(testRdd2).foreach(ele => print(s"$ele "))
输出：
(1,a) (1,b) (1,c) (2,a) (2,b) (2,c) (3,a) (3,b) (3,c)
