SparkCore之RDDAPI編程

編程模型
在Spark中，RDD被表示爲對象，通過對象上的方法調用來對RDD進行轉換。經過一系列的transformations定義RDD之後，就可以調用actions觸發RDD的計算，action可以是嚮應用程序返回結果(count, collect等)，或者是向存儲系統保存數據(saveAsTextFile等)。在Spark中，只有遇到action，纔會執行RDD的計算(即延遲計算)，這樣在運行時可以通過管道的方式傳輸多個轉換。
要使用Spark，開發者需要編寫一個Driver程序，它被提交到集羣以調度運行Worker，如下圖所示。Driver中定義了一個或多個RDD，並調用RDD上的action，Worker則執行RDD分區計算任務。

2.2 RDD的創建

在Spark中創建RDD的創建方式可以分爲三種：從集合中創建RDD；從外部存儲創建RDD；從其他RDD創建。

2.2.1 從集合中創建

從集合中創建RDD，Spark主要提供了兩種函數：parallelize和makeRDD
1）使用parallelize()從集合創建

scala> val rdd = sc.parallelize(Array(1,2,3,4,5,6,7,8))
rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[0] at parallelize at <console>:24

2）使用makeRDD()從集合創建

scala> val rdd1 = sc.makeRDD(Array(1,2,3,4,5,6,7,8))
rdd1: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[1] at makeRDD at <console>:24

2.2.2 由外部存儲系統的數據集創建

包括本地的文件系統，還有所有Hadoop支持的數據集，比如HDFS、Cassandra、HBase等

scala> val rdd2= sc.textFile("hdfs://hadoop102:9000/RELEASE")
rdd2: org.apache.spark.rdd.RDD[String] = hdfs:// hadoop102:9000/RELEASE MapPartitionsRDD[4] at textFile at <console>:24

2.2.3 從其他RDD創建

2.3 RDD的轉換（面試開發重點）

RDD整體上分爲Value類型和Key-Value類型

2.3.1 Value類型

2.3.1.1 map(func)案例

作用：返回一個新的RDD，該RDD由每一個輸入元素經過func函數轉換後組成
需求：創建一個1-10數組的RDD，將所有元素*2形成新的RDD
（1）創建

scala> var source  = sc.parallelize(1 to 10)
source: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[8] at parallelize at <console>:24

（2）打印

scala> source.collect()
res7: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

（3）將所有元素*2

scala> val mapadd = source.map(_ * 2)
mapadd: org.apache.spark.rdd.RDD[Int] = MapPartitionsRDD[9] at map at <console>:26

（4）打印最終結果

scala> mapadd.collect()
res8: Array[Int] = Array(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)

2.3.1.2 mapPartitions(func) 案例

作用：類似於map，但獨立地在RDD的每一個分片上運行，因此在類型爲T的RDD上運行時，func的函數類型必須是Iterator[T] => Iterator[U]。假設有N個元素，有M個分區，那麼map的函數的將被調用N次,而mapPartitions被調用M次,一個函數一次處理所有分區。
需求：創建一個RDD，使每個元素*2組成新的RDD
（1）創建一個RDD

scala> val rdd = sc.parallelize(Array(1,2,3,4))
rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[4] at parallelize at <console>:24

（2）使每個元素*2組成新的RDD

scala> rdd.mapPartitions(x=>x.map(_*2))
res3: org.apache.spark.rdd.RDD[Int] = MapPartitionsRDD[6] at mapPartitions at <console>:27

（3）打印新的RDD

scala> res3.collect
res4: Array[Int] = Array(2, 4, 6, 8)

2.3.1.3 mapPartitionsWithIndex(func) 案例

作用：類似於mapPartitions，但func帶有一個整數參數表示分片的索引值，因此在類型爲T的RDD上運行時，func的函數類型必須是(Int, Interator[T]) => Iterator[U]；
需求：創建一個RDD，使每個元素跟所在分區形成一個元組組成一個新的RDD
（1）創建一個RDD

scala> val rdd = sc.parallelize(Array(1,2,3,4))
rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[4] at parallelize at <console>:24

（2）使每個元素跟所在分區形成一個元組組成一個新的RDD

scala> val indexRdd = rdd.mapPartitionsWithIndex((index,items)=>(items.map((index,_))))
indexRdd: org.apache.spark.rdd.RDD[(Int, Int)] = MapPartitionsRDD[5] at mapPartitionsWithIndex at <console>:26

（3）打印新的RDD

scala> indexRdd.collect
res2: Array[(Int, Int)] = Array((0,1), (0,2), (1,3), (1,4))

2.3.1.4 flatMap(func) 案例

作用：類似於map，但是每一個輸入元素可以被映射爲0或多個輸出元素（所以func應該返回一個序列，而不是單一元素）
需求：創建一個元素爲1-5的RDD，運用flatMap創建一個新的RDD，新的RDD爲原RDD的每個元素的2倍（2，4，6，8，10）
（1）創建

scala> val sourceFlat = sc.parallelize(1 to 5)
sourceFlat: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[12] at parallelize at <console>:24

（2）打印

scala> sourceFlat.collect()
res11: Array[Int] = Array(1, 2, 3, 4, 5)

（3）根據原RDD創建新RDD（1->1,2->1,2……5->1,2,3,4,5）

scala> val flatMap = sourceFlat.flatMap(1 to _)
flatMap: org.apache.spark.rdd.RDD[Int] = MapPartitionsRDD[13] at flatMap at <console>:26

（4）打印新RDD

scala> flatMap.collect()
res12: Array[Int] = Array(1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 2, 3, 4, 5)

2.3.1.5 map()和mapPartition()的區別

map()：每次處理一條數據。
mapPartition()：每次處理一個分區的數據，這個分區的數據處理完後，原RDD中分區的數據才能釋放，可能導致OOM。
開發指導：當內存空間較大的時候建議使用mapPartition()，以提高處理效率。
2.3.1.6 glom案例
作用：將每一個分區形成一個數組，形成新的RDD類型時RDD[Array[T]]
需求：創建一個4個分區的RDD，並將每個分區的數據放到一個數組
（1）創建

scala> val rdd = sc.parallelize(1 to 16,4)
rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[65] at parallelize at <console>:24

（2）將每個分區的數據放到一個數組並收集到Driver端打印

scala> rdd.glom().collect()
res25: Array[Array[Int]] = Array(Array(1, 2, 3, 4), Array(5, 6, 7, 8), Array(9, 10, 11, 12), Array(13, 14, 15, 16))

2.3.1.7 groupBy(func)案例

作用：分組，按照傳入函數的返回值進行分組。將相同的key對應的值放入一個迭代器。
需求：創建一個RDD，按照元素模以2的值進行分組。
（1）創建

scala> val rdd = sc.parallelize(1 to 4)
rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[65] at parallelize at <console>:24

（2）按照元素模以2的值進行分組

scala> val group = rdd.groupBy(_%2)
group: org.apache.spark.rdd.RDD[(Int, Iterable[Int])] = ShuffledRDD[2] at groupBy at <console>:26

（3）打印結果

scala> group.collect
res0: Array[(Int, Iterable[Int])] = Array((0,CompactBuffer(2, 4)), (1,CompactBuffer(1, 3)))

2.3.1.8 filter(func) 案例

作用：過濾。返回一個新的RDD，該RDD由經過func函數計算後返回值爲true的輸入元素組成。
需求：創建一個RDD（由字符串組成），過濾出一個新RDD（包含”xiao”子串）
（1）創建

scala> var sourceFilter = sc.parallelize(Array("xiaoming","xiaojiang","xiaohe","dazhi"))
sourceFilter: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[10] at parallelize at <console>:24

（2）打印

scala> sourceFilter.collect()
res9: Array[String] = Array(xiaoming, xiaojiang, xiaohe, dazhi)

（3）過濾出含” xiao”子串的形成一個新的RDD

scala> val filter = sourceFilter.filter(_.contains("xiao"))
filter: org.apache.spark.rdd.RDD[String] = MapPartitionsRDD[11] at filter at <console>:26

（4）打印新RDD

scala> filter.collect()
res10: Array[String] = Array(xiaoming, xiaojiang, xiaohe)

2.3.1.9 sample(withReplacement, fraction, seed) 案例

作用：以指定的隨機種子隨機抽樣出數量爲fraction的數據，withReplacement表示是抽出的數據是否放回，true爲有放回的抽樣，false爲無放回的抽樣，seed用於指定隨機數生成器種子。
需求：創建一個RDD（1-10），從中選擇放回和不放回抽樣
（1）創建RDD

scala> val rdd = sc.parallelize(1 to 10)
rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[20] at parallelize at <console>:24

（2）打印

scala> rdd.collect()
res15: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

（3）放回抽樣

scala> var sample1 = rdd.sample(true,0.4,2)
sample1: org.apache.spark.rdd.RDD[Int] = PartitionwiseSampledRDD[21] at sample at <console>:26

（4）打印放回抽樣結果

scala> sample1.collect()
res16: Array[Int] = Array(1, 2, 2, 7, 7, 8, 9)

（5）不放回抽樣

scala> var sample2 = rdd.sample(false,0.2,3)
sample2: org.apache.spark.rdd.RDD[Int] = PartitionwiseSampledRDD[22] at sample at <console>:26

（6）打印不放回抽樣結果

scala> sample2.collect()
res17: Array[Int] = Array(1, 9)

2.3.1.10 distinct([numTasks])) 案例

作用：對源RDD進行去重後返回一個新的RDD。默認情況下，只有8個並行任務來操作，但是可以傳入一個可選的numTasks參數改變它。
需求：創建一個RDD，使用distinct()對其去重。
（1）創建一個RDD

scala> val distinctRdd = sc.parallelize(List(1,2,1,5,2,9,6,1))
distinctRdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[34] at parallelize at <console>:24

（2）對RDD進行去重（不指定並行度）

scala> val unionRDD = distinctRdd.distinct()
unionRDD: org.apache.spark.rdd.RDD[Int] = MapPartitionsRDD[37] at distinct at <console>:26

（3）打印去重後生成的新RDD

scala> unionRDD.collect()
res20: Array[Int] = Array(1, 9, 5, 6, 2)

（4）對RDD（指定並行度爲2）

scala> val unionRDD = distinctRdd.distinct(2)
unionRDD: org.apache.spark.rdd.RDD[Int] = MapPartitionsRDD[40] at distinct at <console>:26

（5）打印去重後生成的新RDD

scala> unionRDD.collect()
res21: Array[Int] = Array(6, 2, 1, 9, 5)

2.3.1.11 coalesce(numPartitions) 案例

作用：縮減分區數，用於大數據集過濾後，提高小數據集的執行效率。
需求：創建一個4個分區的RDD，對其縮減分區
（1）創建一個RDD

scala> val rdd = sc.parallelize(1 to 16,4)
rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[54] at parallelize at <console>:24

（2）查看RDD的分區數

scala> rdd.partitions.size
res20: Int = 4

（3）對RDD重新分區

scala> val coalesceRDD = rdd.coalesce(3)
coalesceRDD: org.apache.spark.rdd.RDD[Int] = CoalescedRDD[55] at coalesce at <console>:26

（4）查看新RDD的分區數

scala> coalesceRDD.partitions.size
res21: Int = 3

2.3.1.12 repartition(numPartitions) 案例

作用：根據分區數，重新通過網絡隨機洗牌所有數據。
需求：創建一個4個分區的RDD，對其重新分區
（1）創建一個RDD

scala> val rdd = sc.parallelize(1 to 16,4)
rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[56] at parallelize at <console>:24

（2）查看RDD的分區數

scala> rdd.partitions.size
res22: Int = 4

（3）對RDD重新分區

scala> val rerdd = rdd.repartition(2)
rerdd: org.apache.spark.rdd.RDD[Int] = MapPartitionsRDD[60] at repartition at <console>:26

（4）查看新RDD的分區數

scala> rerdd.partitions.size
res23: Int = 2

2.3.1.13 coalesce和repartition的區別

coalesce重新分區，可以選擇是否進行shuffle過程。由參數shuffle: Boolean = false/true決定。
repartition實際上是調用的coalesce，默認是進行shuffle的。源碼如下：

def repartition(numPartitions: Int)(implicit ord: Ordering[T] = null): RDD[T] = withScope {
  coalesce(numPartitions, shuffle = true)
}

2.3.1.14 sortBy(func,[ascending], [numTasks]) 案例

作用；使用func先對數據進行處理，按照處理後的數據比較結果排序，默認爲正序。
需求：創建一個RDD，按照不同的規則進行排序
（1）創建一個RDD

scala> val rdd = sc.parallelize(List(2,1,3,4))
rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[21] at parallelize at <console>:24

（2）按照自身大小排序

scala> rdd.sortBy(x => x).collect()
res11: Array[Int] = Array(1, 2, 3, 4)

（3）按照與3餘數的大小排序

scala> rdd.sortBy(x => x%3).collect()
res12: Array[Int] = Array(3, 4, 1, 2)

2.3.1.15 pipe(command, [envVars]) 案例

作用：管道，針對每個分區，都執行一個shell腳本，返回輸出的RDD。
注意：腳本需要放在Worker節點可以訪問到的位置
需求：編寫一個腳本，使用管道將腳本作用於RDD上。
（1）編寫一個腳本

Shell腳本
#!/bin/sh
echo "AA"
while read LINE; do
   echo ">>>"${LINE}
done

（2）創建一個只有一個分區的RDD

scala> val rdd = sc.parallelize(List("hi","Hello","how","are","you"),1)
rdd: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[50] at parallelize at <console>:24

（3）將腳本作用該RDD並打印

scala> rdd.pipe("/opt/module/spark/pipe.sh").collect()
res18: Array[String] = Array(AA, >>>hi, >>>Hello, >>>how, >>>are, >>>you)

（4）創建一個有兩個分區的RDD

scala> val rdd = sc.parallelize(List("hi","Hello","how","are","you"),2)
rdd: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[52] at parallelize at <console>:24

（5）將腳本作用該RDD並打印

scala> rdd.pipe("/opt/module/spark/pipe.sh").collect()
res19: Array[String] = Array(AA, >>>hi, >>>Hello, AA, >>>how, >>>are, >>>you)

2.3.2 雙Value類型交互

2.3.2.1 union(otherDataset) 案例

作用：對源RDD和參數RDD求並集後返回一個新的RDD
需求：創建兩個RDD，求並集
（1）創建第一個RDD

scala> val rdd1 = sc.parallelize(1 to 5)
rdd1: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[23] at parallelize at <console>:24

（2）創建第二個RDD

scala> val rdd2 = sc.parallelize(5 to 10)
rdd2: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[24] at parallelize at <console>:24

（3）計算兩個RDD的並集

scala> val rdd3 = rdd1.union(rdd2)
rdd3: org.apache.spark.rdd.RDD[Int] = UnionRDD[25] at union at <console>:28

（4）打印並集結果

scala> rdd3.collect()
res18: Array[Int] = Array(1, 2, 3, 4, 5, 5, 6, 7, 8, 9, 10)

2.3.2.2 subtract (otherDataset) 案例

作用：計算差的一種函數，去除兩個RDD中相同的元素，不同的RDD將保留下來
需求：創建兩個RDD，求第一個RDD與第二個RDD的差集
（1）創建第一個RDD

scala> val rdd = sc.parallelize(3 to 8)
rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[70] at parallelize at <console>:24

（2）創建第二個RDD

scala> val rdd1 = sc.parallelize(1 to 5)
rdd1: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[71] at parallelize at <console>:24

（3）計算第一個RDD與第二個RDD的差集並打印

scala> rdd.subtract(rdd1).collect()
res27: Array[Int] = Array(8, 6, 7)

2.3.2.3 intersection(otherDataset) 案例

作用：對源RDD和參數RDD求交集後返回一個新的RDD
需求：創建兩個RDD，求兩個RDD的交集
（1）創建第一個RDD

scala> val rdd1 = sc.parallelize(1 to 7)
rdd1: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[26] at parallelize at <console>:24

（2）創建第二個RDD

scala> val rdd2 = sc.parallelize(5 to 10)
rdd2: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[27] at parallelize at <console>:24

（3）計算兩個RDD的交集

scala> val rdd3 = rdd1.intersection(rdd2)
rdd3: org.apache.spark.rdd.RDD[Int] = MapPartitionsRDD[33] at intersection at <console>:28

（4）打印計算結果

scala> rdd3.collect()
res19: Array[Int] = Array(5, 6, 7)

2.3.2.4 cartesian(otherDataset) 案例

作用：笛卡爾積（儘量避免使用）
需求：創建兩個RDD，計算兩個RDD的笛卡爾積
（1）創建第一個RDD

scala> val rdd1 = sc.parallelize(1 to 3)
rdd1: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[47] at parallelize at <console>:24

（2）創建第二個RDD

scala> val rdd2 = sc.parallelize(2 to 5)
rdd2: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[48] at parallelize at <console>:24

（3）計算兩個RDD的笛卡爾積並打印

scala> rdd1.cartesian(rdd2).collect()
res17: Array[(Int, Int)] = Array((1,2), (1,3), (1,4), (1,5), (2,2), (2,3), (2,4), (2,5), (3,2), (3,3), (3,4), (3,5))

2.3.2.5 zip(otherDataset)案例

作用：將兩個RDD組合成Key/Value形式的RDD,這裏默認兩個RDD的partition數量以及元素數量都相同，否則會拋出異常。
需求：創建兩個RDD，並將兩個RDD組合到一起形成一個(k,v)RDD
（1）創建第一個RDD

scala> val rdd1 = sc.parallelize(Array(1,2,3),3)
rdd1: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[1] at parallelize at <console>:24

（2）創建第二個RDD（與1分區數相同）

scala> val rdd2 = sc.parallelize(Array("a","b","c"),3)
rdd2: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[2] at parallelize at <console>:24

（3）第一個RDD組合第二個RDD並打印

scala> rdd1.zip(rdd2).collect
res1: Array[(Int, String)] = Array((1,a), (2,b), (3,c))

（4）第二個RDD組合第一個RDD並打印

scala> rdd2.zip(rdd1).collect
res2: Array[(String, Int)] = Array((a,1), (b,2), (c,3))

（5）創建第三個RDD（與1,2分區數不同）

scala> val rdd3 = sc.parallelize(Array("a","b","c"),2)
rdd3: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[5] at parallelize at <console>:24

（6）第一個RDD組合第三個RDD並打印

scala> rdd1.zip(rdd3).collect
java.lang.IllegalArgumentException: Can't zip RDDs with unequal numbers of partitions: List(3, 2)
  at org.apache.spark.rdd.ZippedPartitionsBaseRDD.getPartitions(ZippedPartitionsRDD.scala:57)
  at org.apache.spark.rdd.RDD$$anonfun$partitions$2.apply(RDD.scala:252)
  at org.apache.spark.rdd.RDD$$anonfun$partitions$2.apply(RDD.scala:250)
  at scala.Option.getOrElse(Option.scala:121)
  at org.apache.spark.rdd.RDD.partitions(RDD.scala:250)
  at org.apache.spark.SparkContext.runJob(SparkContext.scala:1965)
  at org.apache.spark.rdd.RDD$$anonfun$collect$1.apply(RDD.scala:936)
  at org.apache.spark.rdd.RDDOperationScope$.withScope(RDDOperationScope.scala:151)
  at org.apache.spark.rdd.RDDOperationScope$.withScope(RDDOperationScope.scala:112)
  at org.apache.spark.rdd.RDD.withScope(RDD.scala:362)
  at org.apache.spark.rdd.RDD.collect(RDD.scala:935)
  ... 48 elided

2.3.3 Key-Value類型

2.3.3.1 partitionBy案例

作用：對pairRDD進行分區操作，如果原有的partionRDD和現有的partionRDD是一致的話就不進行分區，否則會生成ShuffleRDD，即會產生shuffle過程。
需求：創建一個4個分區的RDD，對其重新分區
（1）創建一個RDD

scala> val rdd = sc.parallelize(Array((1,"aaa"),(2,"bbb"),(3,"ccc"),(4,"ddd")),4)
rdd: org.apache.spark.rdd.RDD[(Int, String)] = ParallelCollectionRDD[44] at parallelize at <console>:24

（2）查看RDD的分區數

scala> rdd.partitions.size
res24: Int = 4

（3）對RDD重新分區

scala> var rdd2 = rdd.partitionBy(new org.apache.spark.HashPartitioner(2))
rdd2: org.apache.spark.rdd.RDD[(Int, String)] = ShuffledRDD[45] at partitionBy at <console>:26

（4）查看新RDD的分區數

scala> rdd2.partitions.size
res25: Int = 2

2.3.3.2 groupByKey案例

作用：groupByKey也是對每個key進行操作，但只生成一個sequence。
需求：創建一個pairRDD，將相同key對應值聚合到一個sequence中，並計算相同key對應值的相加結果。
（1）創建一個pairRDD

scala> val words = Array("one", "two", "two", "three", "three", "three")
words: Array[String] = Array(one, two, two, three, three, three)

scala> val wordPairsRDD = sc.parallelize(words).map(word => (word, 1))
wordPairsRDD: org.apache.spark.rdd.RDD[(String, Int)] = MapPartitionsRDD[4] at map at <console>:26

（2）將相同key對應值聚合到一個sequence中

scala> val group = wordPairsRDD.groupByKey()
group: org.apache.spark.rdd.RDD[(String, Iterable[Int])] = ShuffledRDD[5] at groupByKey at <console>:28

（3）打印結果

scala> group.collect()
res1: Array[(String, Iterable[Int])] = Array((two,CompactBuffer(1, 1)), (one,CompactBuffer(1)), (three,CompactBuffer(1, 1, 1)))

（4）計算相同key對應值的相加結果

scala> group.map(t => (t._1, t._2.sum))
res2: org.apache.spark.rdd.RDD[(String, Int)] = MapPartitionsRDD[6] at map at <console>:31

（5）打印結果

scala> res2.collect()
res3: Array[(String, Int)] = Array((two,2), (one,1), (three,3))

2.3.3.3 reduceByKey(func, [numTasks]) 案例

在一個(K,V)的RDD上調用，返回一個(K,V)的RDD，使用指定的reduce函數，將相同key的值聚合到一起，reduce任務的個數可以通過第二個可選的參數來設置。
需求：創建一個pairRDD，計算相同key對應值的相加結果
（1）創建一個pairRDD

scala> val rdd = sc.parallelize(List(("female",1),("male",5),("female",5),("male",2)))
rdd: org.apache.spark.rdd.RDD[(String, Int)] = ParallelCollectionRDD[46] at parallelize at <console>:24

（2）計算相同key對應值的相加結果

scala> val reduce = rdd.reduceByKey((x,y) => x+y)
reduce: org.apache.spark.rdd.RDD[(String, Int)] = ShuffledRDD[47] at reduceByKey at <console>:26

（3）打印結果

scala> reduce.collect()
res29: Array[(String, Int)] = Array((female,6), (male,7))

2.3.3.4 reduceByKey和groupByKey的區別

reduceByKey：按照key進行聚合，在shuffle之前有combine（預聚合）操作，返回結果是RDD[k,v].
groupByKey：按照key進行分組，直接進行shuffle。
開發指導：reduceByKey比groupByKey，建議使用。但是需要注意是否會影響業務邏輯。

2.3.3.5 aggregateByKey案例

參數：(zeroValue:U,[partitioner: Partitioner]) (seqOp: (U, V) => U,combOp: (U, U) => U)

作用：在kv對的RDD中，，按key將value進行分組合並，合併時，將每個value和初始值作爲seq函數的參數，進行計算，返回的結果作爲一個新的kv對，然後再將結果按照key進行合併，最後將每個分組的value傳遞給combine函數進行計算（先將前兩個value進行計算，將返回結果和下一個value傳給combine函數，以此類推），將key與計算結果作爲一個新的kv對輸出。
參數描述：
（1）zeroValue：給每一個分區中的每一個key一個初始值；
（2）seqOp：函數用於在每一個分區中用初始值逐步迭代value；
（3）combOp：函數用於合併每個分區中的結果。
需求：創建一個pairRDD，取出每個分區相同key對應值的最大值，然後相加
需求分析

（1）創建一個pairRDD

scala> val rdd = sc.parallelize(List(("a",3),("a",2),("c",4),("b",3),("c",6),("c",8)),2)
rdd: org.apache.spark.rdd.RDD[(String, Int)] = ParallelCollectionRDD[0] at parallelize at <console>:24

（2）取出每個分區相同key對應值的最大值，然後相加

scala> val agg = rdd.aggregateByKey(0)(math.max(_,_),_+_)
agg: org.apache.spark.rdd.RDD[(String, Int)] = ShuffledRDD[1] at aggregateByKey at <console>:26

（3）打印結果

scala> agg.collect()
res0: Array[(String, Int)] = Array((b,3), (a,3), (c,12))

2.3.3.6 foldByKey案例

參數：(zeroValue: V)(func: (V, V) => V): RDD[(K, V)]
1.作用：aggregateByKey的簡化操作，seqop和combop相同
2.需求：創建一個pairRDD，計算相同key對應值的相加結果
（1）創建一個pairRDD

scala> val rdd = sc.parallelize(List((1,3),(1,2),(1,4),(2,3),(3,6),(3,8)),3)
rdd: org.apache.spark.rdd.RDD[(Int, Int)] = ParallelCollectionRDD[91] at parallelize at <console>:24

（2）計算相同key對應值的相加結果

scala> val agg = rdd.foldByKey(0)(_+_)
agg: org.apache.spark.rdd.RDD[(Int, Int)] = ShuffledRDD[92] at foldByKey at <console>:26

（3）打印結果

scala> agg.collect()
res61: Array[(Int, Int)] = Array((3,14), (1,9), (2,3))

2.3.3.7 combineByKey[C] 案例

參數：(createCombiner: V => C, mergeValue: (C, V) => C, mergeCombiners: (C, C) => C)
1.作用：對相同K，把V合併成一個集合。
2.參數描述：
（1）createCombiner: combineByKey() 會遍歷分區中的所有元素，因此每個元素的鍵要麼還沒有遇到過，要麼就和之前的某個元素的鍵相同。如果這是一個新的元素,combineByKey()會使用一個叫作createCombiner()的函數來創建那個鍵對應的累加器的初始值
（2）mergeValue: 如果這是一個在處理當前分區之前已經遇到的鍵，它會使用mergeValue()方法將該鍵的累加器對應的當前值與這個新的值進行合併
（3）mergeCombiners: 由於每個分區都是獨立處理的，因此對於同一個鍵可以有多個累加器。如果有兩個或者更多的分區都有對應同一個鍵的累加器，就需要使用用戶提供的 mergeCombiners() 方法將各個分區的結果進行合併。
3.需求：創建一個pairRDD，根據key計算每種key的均值。（先計算每個key出現的次數以及可以對應值的總和，再相除得到結果）
4.需求分析：

（1）創建一個pairRDD

scala> val input = sc.parallelize(Array(("a", 88), ("b", 95), ("a", 91), ("b", 93), ("a", 95), ("b", 98)),2)
input: org.apache.spark.rdd.RDD[(String, Int)] = ParallelCollectionRDD[52] at parallelize at <console>:26

（2）將相同key對應的值相加，同時記錄該key出現的次數，放入一個二元組

scala> val combine = input.combineByKey((_,1),(acc:(Int,Int),v)=>(acc._1+v,acc._2+1),(acc1:(Int,Int),acc2:(Int,Int))=>(acc1._1+acc2._1,acc1._2+acc2._2))
combine: org.apache.spark.rdd.RDD[(String, (Int, Int))] = ShuffledRDD[5] at combineByKey at <console>:28

（3）打印合並後的結果

scala> combine.collect
res5: Array[(String, (Int, Int))] = Array((b,(286,3)), (a,(274,3)))

（4）計算平均值

scala> val result = combine.map{case (key,value) => (key,value._1/value._2.toDouble)}
result: org.apache.spark.rdd.RDD[(String, Double)] = MapPartitionsRDD[54] at map at <console>:30

（5）打印結果

scala> result.collect()
res33: Array[(String, Double)] = Array((b,95.33333333333333), (a,91.33333333333333))

2.3.3.8 sortByKey([ascending], [numTasks]) 案例

作用：在一個(K,V)的RDD上調用，K必須實現Ordered接口，返回一個按照key進行排序的(K,V)的RDD
需求：創建一個pairRDD，按照key的正序和倒序進行排序
（1）創建一個pairRDD

scala> val rdd = sc.parallelize(Array((3,"aa"),(6,"cc"),(2,"bb"),(1,"dd")))
rdd: org.apache.spark.rdd.RDD[(Int, String)] = ParallelCollectionRDD[14] at parallelize at <console>:24

（2）按照key的正序

scala> rdd.sortByKey(true).collect()
res9: Array[(Int, String)] = Array((1,dd), (2,bb), (3,aa), (6,cc))

（3）按照key的倒序

scala> rdd.sortByKey(false).collect()
res10: Array[(Int, String)] = Array((6,cc), (3,aa), (2,bb), (1,dd))

2.3.3.9 mapValues案例

針對於(K,V)形式的類型只對V進行操作
需求：創建一個pairRDD，並將value添加字符串"|||"
（1）創建一個pairRDD

scala> val rdd3 = sc.parallelize(Array((1,"a"),(1,"d"),(2,"b"),(3,"c")))
rdd3: org.apache.spark.rdd.RDD[(Int, String)] = ParallelCollectionRDD[67] at parallelize at <console>:24

（2）對value添加字符串"|||"

scala> rdd3.mapValues(_+"|||").collect()
res26: Array[(Int, String)] = Array((1,a|||), (1,d|||), (2,b|||), (3,c|||))

2.3.3.10 join(otherDataset, [numTasks]) 案例

作用：在類型爲(K,V)和(K,W)的RDD上調用，返回一個相同key對應的所有元素對在一起的(K,(V,W))的RDD
需求：創建兩個pairRDD，並將key相同的數據聚合到一個元組。
（1）創建第一個pairRDD

scala> val rdd = sc.parallelize(Array((1,"a"),(2,"b"),(3,"c")))
rdd: org.apache.spark.rdd.RDD[(Int, String)] = ParallelCollectionRDD[32] at parallelize at <console>:24

（2）創建第二個pairRDD

scala> val rdd1 = sc.parallelize(Array((1,4),(2,5),(3,6)))
rdd1: org.apache.spark.rdd.RDD[(Int, Int)] = ParallelCollectionRDD[33] at parallelize at <console>:24

（3）join操作並打印結果

scala> rdd.join(rdd1).collect()
res13: Array[(Int, (String, Int))] = Array((1,(a,4)), (2,(b,5)), (3,(c,6)))

2.3.3.11 cogroup(otherDataset, [numTasks]) 案例

作用：在類型爲(K,V)和(K,W)的RDD上調用，返回一個(K,(Iterable,Iterable))類型的RDD
需求：創建兩個pairRDD，並將key相同的數據聚合到一個迭代器。
（1）創建第一個pairRDD

scala> val rdd = sc.parallelize(Array((1,"a"),(2,"b"),(3,"c")))
rdd: org.apache.spark.rdd.RDD[(Int, String)] = ParallelCollectionRDD[37] at parallelize at <console>:24

（2）創建第二個pairRDD

scala> val rdd1 = sc.parallelize(Array((1,4),(2,5),(3,6)))
rdd1: org.apache.spark.rdd.RDD[(Int, Int)] = ParallelCollectionRDD[38] at parallelize at <console>:24

（3）cogroup兩個RDD並打印結果

scala> rdd.cogroup(rdd1).collect()
res14: Array[(Int, (Iterable[String], Iterable[Int]))] = Array((1,(CompactBuffer(a),CompactBuffer(4))), (2,(CompactBuffer(b),CompactBuffer(5))), (3,(CompactBuffer(c),CompactBuffer(6))))

2.4 Action

2.4.1 reduce(func)案例

作用：通過func函數聚集RDD中的所有元素，先聚合分區內數據，再聚合分區間數據。
需求：創建一個RDD，將所有元素聚合得到結果。
（1）創建一個RDD[Int]

scala> val rdd1 = sc.makeRDD(1 to 10,2)
rdd1: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[85] at makeRDD at <console>:24

（2）聚合RDD[Int]所有元素

scala> rdd1.reduce(_+_)
res50: Int = 55

（3）創建一個RDD[String]

scala> val rdd2 = sc.makeRDD(Array(("a",1),("a",3),("c",3),("d",5)))
rdd2: org.apache.spark.rdd.RDD[(String, Int)] = ParallelCollectionRDD[86] at makeRDD at <console>:24

（4）聚合RDD[String]所有數據

scala> rdd2.reduce((x,y)=>(x._1 + y._1,x._2 + y._2))
res51: (String, Int) = (adca,12)

2.4.2 collect()案例

作用：在驅動程序中，以數組的形式返回數據集的所有元素。
需求：創建一個RDD，並將RDD內容收集到Driver端打印
（1）創建一個RDD

scala> val rdd = sc.parallelize(1 to 10)
rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[0] at parallelize at <console>:24

（2）將結果收集到Driver端

scala> rdd.collect
res0: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

2.4.3 count()案例

作用：返回RDD中元素的個數
需求：創建一個RDD，統計該RDD的條數
（1）創建一個RDD

scala> val rdd = sc.parallelize(1 to 10)
rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[0] at parallelize at <console>:24

（2）統計該RDD的條數

scala> rdd.count
res1: Long = 10

2.4.4 first()案例

作用：返回RDD中的第一個元素
需求：創建一個RDD，返回該RDD中的第一個元素
（1）創建一個RDD

scala> val rdd = sc.parallelize(1 to 10)
rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[0] at parallelize at <console>:24

（2）統計該RDD的條數

scala> rdd.first
res2: Int = 1

2.4.5 take(n)案例

作用：返回一個由RDD的前n個元素組成的數組
需求：創建一個RDD，統計該RDD的條數
（1）創建一個RDD

scala> val rdd = sc.parallelize(Array(2,5,4,6,8,3))
rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[2] at parallelize at <console>:24

（2）統計該RDD的條數

scala> rdd.take(3)
res10: Array[Int] = Array(2, 5, 4)

2.4.6 takeOrdered(n)案例

作用：返回該RDD排序後的前n個元素組成的數組
需求：創建一個RDD，統計該RDD的條數
（1）創建一個RDD

scala> val rdd = sc.parallelize(Array(2,5,4,6,8,3))
rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[2] at parallelize at <console>:24

（2）統計該RDD的條數

scala> rdd.takeOrdered(3)
res18: Array[Int] = Array(2, 3, 4)

2.4.7 aggregate案例

參數：(zeroValue: U)(seqOp: (U, T) ⇒ U, combOp: (U, U) ⇒ U)
作用：aggregate函數將每個分區裏面的元素通過seqOp和初始值進行聚合，然後用combine函數將每個分區的結果和初始值(zeroValue)進行combine操作。這個函數最終返回的類型不需要和RDD中元素類型一致。
需求：創建一個RDD，將所有元素相加得到結果
（1）創建一個RDD

scala> var rdd1 = sc.makeRDD(1 to 10,2)
rdd1: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[88] at makeRDD at <console>:24

（2）將該RDD所有元素相加得到結果

scala> rdd.aggregate(0)(_+_,_+_)
res22: Int = 55

2.4.8 fold(num)(func)案例

作用：摺疊操作，aggregate的簡化操作，seqop和combop一樣。
需求：創建一個RDD，將所有元素相加得到結果
（1）創建一個RDD

scala> var rdd1 = sc.makeRDD(1 to 10,2)
rdd1: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[88] at makeRDD at <console>:24

（2）將該RDD所有元素相加得到結果

scala> rdd.fold(0)(_+_)
res24: Int = 55

2.4.9 saveAsTextFile(path)

作用：將數據集的元素以textfile的形式保存到HDFS文件系統或者其他支持的文件系統，對於每個元素，Spark將會調用toString方法，將它裝換爲文件中的文本

2.4.10 saveAsSequenceFile(path)

作用：將數據集中的元素以Hadoop sequencefile的格式保存到指定的目錄下，可以使HDFS或者其他Hadoop支持的文件系統。

2.4.11 saveAsObjectFile(path)

作用：用於將RDD中的元素序列化成對象，存儲到文件中。

2.4.12 countByKey()案例

作用：針對(K,V)類型的RDD，返回一個(K,Int)的map，表示每一個key對應的元素個數。
需求：創建一個PairRDD，統計每種key的個數
（1）創建一個PairRDD

scala> val rdd = sc.parallelize(List((1,3),(1,2),(1,4),(2,3),(3,6),(3,8)),3)
rdd: org.apache.spark.rdd.RDD[(Int, Int)] = ParallelCollectionRDD[95] at parallelize at <console>:24

（2）統計每種key的個數

scala> rdd.countByKey
res63: scala.collection.Map[Int,Long] = Map(3 -> 2, 1 -> 3, 2 -> 1)

2.4.13 foreach(func)案例

作用：在數據集的每一個元素上，運行函數func進行更新。
需求：創建一個RDD，對每個元素進行打印
（1）創建一個RDD

scala> var rdd = sc.makeRDD(1 to 5,2)
rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[107] at makeRDD at <console>:24

（2）對該RDD每個元素進行打印

scala> rdd.foreach(println(_))
3
4
5
1
2

2.5 RDD中的函數傳遞
在實際開發中我們往往需要自己定義一些對於RDD的操作，那麼此時需要主要的是，初始化工作是在Driver端進行的，而實際運行程序是在Executor端進行的，這就涉及到了跨進程通信，是需要序列化的。下面我們看幾個例子：
2.5.1 傳遞一個方法
1．創建一個類

class Search(s:String){

//過濾出包含字符串的數據
  def isMatch(s: String): Boolean = {
    s.contains(query)
  }

//過濾出包含字符串的RDD
  def getMatch1 (rdd: RDD[String]): RDD[String] = {
    rdd.filter(isMatch)
  }

  //過濾出包含字符串的RDD
  def getMatche2(rdd: RDD[String]): RDD[String] = {
    rdd.filter(x => x.contains(query))
  }

}

2．創建Spark主程序

object SeriTest {

  def main(args: Array[String]): Unit = {

    //1.初始化配置信息及SparkContext
    val sparkConf: SparkConf = new SparkConf().setAppName("WordCount").setMaster("local[*]")
    val sc = new SparkContext(sparkConf)

//2.創建一個RDD
    val rdd: RDD[String] = sc.parallelize(Array("hadoop", "spark", "hive", "atguigu"))

//3.創建一個Search對象
    val search = new Search()

//4.運用第一個過濾函數並打印結果
    val match1: RDD[String] = search.getMatche1(rdd)
    match1.collect().foreach(println)
    }
}

3．運行程序

Exception in thread "main" org.apache.spark.SparkException: Task not serializable
    at org.apache.spark.util.ClosureCleaner$.ensureSerializable(ClosureCleaner.scala:298)
    at org.apache.spark.util.ClosureCleaner$.org$apache$spark$util$ClosureCleaner$$clean(ClosureCleaner.scala:288)
    at org.apache.spark.util.ClosureCleaner$.clean(ClosureCleaner.scala:108)
    at org.apache.spark.SparkContext.clean(SparkContext.scala:2101)
    at org.apache.spark.rdd.RDD$$anonfun$filter$1.apply(RDD.scala:387)
    at org.apache.spark.rdd.RDD$$anonfun$filter$1.apply(RDD.scala:386)
    at org.apache.spark.rdd.RDDOperationScope$.withScope(RDDOperationScope.scala:151)
    at org.apache.spark.rdd.RDDOperationScope$.withScope(RDDOperationScope.scala:112)
    at org.apache.spark.rdd.RDD.withScope(RDD.scala:362)
    at org.apache.spark.rdd.RDD.filter(RDD.scala:386)
    at com.atguigu.Search.getMatche1(SeriTest.scala:39)
    at com.atguigu.SeriTest$.main(SeriTest.scala:18)
    at com.atguigu.SeriTest.main(SeriTest.scala)
Caused by: java.io.NotSerializableException: com.atguigu.Search

4．問題說明

//過濾出包含字符串的RDD
  def getMatch1 (rdd: RDD[String]): RDD[String] = {
    rdd.filter(isMatch)
  }

在這個方法中所調用的方法isMatch()是定義在Search這個類中的，實際上調用的是this. isMatch()，this表示Search這個類的對象，程序在運行過程中需要將Search對象序列化以後傳遞到Executor端。
5．解決方案
使類繼承scala.Serializable即可。
class Search() extends Serializable{…}

2.5.2 傳遞一個屬性

1．創建Spark主程序

object TransmitTest {

  def main(args: Array[String]): Unit = {

    //1.初始化配置信息及SparkContext
    val sparkConf: SparkConf = new SparkConf().setAppName("WordCount").setMaster("local[*]")
    val sc = new SparkContext(sparkConf)

//2.創建一個RDD
    val rdd: RDD[String] = sc.parallelize(Array("hadoop", "spark", "hive", "atguigu"))

//3.創建一個Search對象
    val search = new Search()

//4.運用第一個過濾函數並打印結果
    val match1: RDD[String] = search.getMatche2(rdd)
    match1.collect().foreach(println)
    }
}

2．運行程序

Exception in thread "main" org.apache.spark.SparkException: Task not serializable
    at org.apache.spark.util.ClosureCleaner$.ensureSerializable(ClosureCleaner.scala:298)
    at org.apache.spark.util.ClosureCleaner$.org$apache$spark$util$ClosureCleaner$$clean(ClosureCleaner.scala:288)
    at org.apache.spark.util.ClosureCleaner$.clean(ClosureCleaner.scala:108)
    at org.apache.spark.SparkContext.clean(SparkContext.scala:2101)
    at org.apache.spark.rdd.RDD$$anonfun$filter$1.apply(RDD.scala:387)
    at org.apache.spark.rdd.RDD$$anonfun$filter$1.apply(RDD.scala:386)
    at org.apache.spark.rdd.RDDOperationScope$.withScope(RDDOperationScope.scala:151)
    at org.apache.spark.rdd.RDDOperationScope$.withScope(RDDOperationScope.scala:112)
    at org.apache.spark.rdd.RDD.withScope(RDD.scala:362)
    at org.apache.spark.rdd.RDD.filter(RDD.scala:386)
    at com.atguigu.Search.getMatche1(SeriTest.scala:39)
    at com.atguigu.SeriTest$.main(SeriTest.scala:18)
    at com.atguigu.SeriTest.main(SeriTest.scala)
Caused by: java.io.NotSerializableException: com.atguigu.Search

3．問題說明

  //過濾出包含字符串的RDD
  def getMatche2(rdd: RDD[String]): RDD[String] = {
    rdd.filter(x => x.contains(query))
  }

在這個方法中所調用的方法query是定義在Search這個類中的字段，實際上調用的是this. query，this表示Search這個類的對象，程序在運行過程中需要將Search對象序列化以後傳遞到Executor端。
4．解決方案
1）使類繼承scala.Serializable即可。

class Search() extends Serializable{...}

2）將類變量query賦值給局部變量
修改getMatche2爲

  //過濾出包含字符串的RDD
  def getMatche2(rdd: RDD[String]): RDD[String] = {
    val query_ : String = this.query//將類變量賦值給局部變量
    rdd.filter(x => x.contains(query_))
  }