Spark RDD API

1、RDD

RDD（Resilient Distributed Dataset彈性分散式資料集）是Spark中抽象的資料結構型別，任何資料在Spark中都被表示為RDD。從程式設計的角度來看，RDD可以簡單看成是一個陣列。和普通陣列的區別是，RDD中的資料時分割槽儲存的，這樣不同分割槽的資料就可以分佈在不同的機器上，同時可以被並行處理。因此，Spark應用程式所做的無非是把需要處理的資料轉換為RDD，然後對RDD進行一系列的變換和操作，從而得到結果。

2、RDD建立

RDD可以從普通陣列建立出來，也可以從檔案系統或者HDFS中的檔案建立出來。

1) 從普通陣列建立RDD，裡面包含了1到9這9個數字，它們分別在3個分割槽中

scala> val a = sc.parallelize(1 to 9, 3)

2)讀取檔案README.md來建立RDD，檔案中的每一行就是RDD中的一個元素

scala> val b = sc.textFile("README.md")

3、兩類操作運算元

主要分兩類，轉換（transformation）和動作（action）。兩類函式的主要區別是，transformation接受RDD並返回RDD，而action接受RDD返回非RDD.

transformation操作是延遲計算的，也就是說從一個RDD生成另一個RDD的轉換操作不是馬上執行，需要等到有action操作的時候才真正觸發運算。

action運算元會觸發spark提交作業job，並將資料輸出spark系統。

4、轉換運算元

更多可以參看 

1）map

對RDD中的每個元素都執行一個指定的函式來產生一個新的RDD。任何原RDD中的元素在新RDD中都有且只有一個元素與之對應。

舉例：

scala> val a = sc.parallelize(1 to 9, 3)

scala> val b = a.map(x => x*2)

scala> a.collect

res10: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)

scala> b.collect

res11: Array[Int] = Array(2, 4, 6, 8, 10, 12, 14, 16, 18)

2）flatMap

與map類似，區別是原RDD中的元素經map處理後只能生成一個元素，而原RDD中的元素經flatmap處理後可生成多個元素來構建新RDD。

舉例：對原RDD中的每個元素x產生y個元素（從1到y，y為元素x的值）

scala> val a = sc.parallelize(1 to 4, 2)

scala> val b = a.flatMap(x => 1 to x)

scala> b.collect

res12: Array[Int] = Array(1, 1, 2, 1, 2, 3, 1, 2, 3, 4,1,2,3,4)

3）mapPartitions

mapPartitions是map的一個變種。map的輸入函式是應用於RDD中每個元素，而mapPartitions的輸入函式是應用於每個分割槽，也就是把每個分割槽中的內容作為整體來處理的。

它的函式定義為：

def mapPartitions[U: ClassTag](f: Iterator[T] => Iterator[U], preservesPartitioning: Boolean = false): RDD[U]

f即為輸入函式，它處理每個分割槽裡面的內容。每個分割槽中的內容將以Iterator[T]傳遞給輸入函式f，f的輸出結果是Iterator[U]。最終的RDD由所有分割槽經過輸入函式處理後的結果合併起來的。

舉例：

上述例子中的函式myfunc是把分割槽中一個元素和它的下一個元素組成一個Tuple。因為分割槽中最後一個元素沒有下一個元素了，所以(3,4)和(6,7)不在結果中。

mapPartitions還有些變種，比如mapPartitionsWithContext，它能把處理過程中的一些狀態資訊傳遞給使用者指定的輸入函式。還有mapPartitionsWithIndex，它能把分割槽的index傳遞給使用者指定的輸入函式。

4）mapWith

是map的另外一個變種，map只需要一個輸入函式，而mapWith有兩個輸入函式。它的定義如下：

def mapWith[A: ClassTag, U: ](constructA: Int => A, preservesPartitioning: Boolean = false)(f: (T, A) => U): RDD[U]

第一個函式constructA是把RDD的partition index（index從0開始）作為輸入，輸出為新型別A；

第二個函式f是把二元組(T, A)作為輸入（其中T為原RDD中的元素，A為第一個函式的輸出），輸出型別為U。

舉例：把partition index 乘以10，然後加上2作為新的RDD的元素。

val x = sc.parallelize(List(1,2,3,4,5,6,7,8,9,10), 3)

x.mapWith(a => a * 10)((a, b) => (b + 2)).collect

res4: Array[Int] = Array(2, 2, 2, 12, 12, 12, 22, 22, 22, 22)

5）flatMapWith

flatMapWith與mapWith很類似，都是接收兩個函式，一個函式把partitionIndex作為輸入，輸出是一個新型別A；另外一個函式是以二元組（T,A）作為輸入，輸出為一個序列，這些序列裡面的元素組成了新的RDD。它的定義如下：

def flatMapWith[A: ClassTag, U: ClassTag](constructA: Int => A, preservesPartitioning: Boolean = false)(f: (T, A) => Seq[U]): RDD[U]

舉例：

scala> val a = sc.parallelize(List(1,2,3,4,5,6,7,8,9), 3)

scala> a.flatMapWith(x => x, true)((x, y) => List(y, x)).collect

res58: Array[Int] = Array(0, 1, 0, 2, 0, 3, 1, 4, 1, 5, 1, 6, 2, 7, 2,8, 2, 9)

6）flatMapValues

flatMapValues類似於mapValues，不同的在於flatMapValues應用於元素為KV對的RDD中Value。每個一元素的Value被輸入函式對映為一系列的值，然後這些值再與原RDD中的Key組成一系列新的KV對。

舉例

scala> val a = sc.parallelize(List((1,2),(3,4),(3,6)))

scala> val b = a.flatMapValues(x=>x.to(5))

scala> b.collect

res3: Array[(Int, Int)] = Array((1,2), (1,3), (1,4), (1,5), (3,4), (3,5))

上述例子中原RDD中每個元素的值被轉換為一個序列（從其當前值到5），比如第一個KV對(1,2), 其值2被轉換為2，3，4，5。然後其再與原KV對中Key組成一系列新的KV對(1,2),(1,3),(1,4),(1,5)。

7）union

8）cartesian

9）groupBy

10）filter

當需要比較不同型別資料時，參照 ：

11）sample

12）Cache

將RDD元素從磁碟快取到記憶體

如果資料需要複用，可以透過Cache運算元，將資料快取到記憶體。

13）persist

14）mapValues

顧名思義就是輸入函式應用於RDD中Kev-Value的Value，原RDD中的Key保持不變，與新的Value一起組成新的RDD中的元素。因此，該函式只適用於元素為KV對的RDD。

舉例：

scala> val a = sc.parallelize(List("dog", "tiger", "lion", "cat", "panther", " eagle"), 2)

scala> val b = a.map(x => (x.length, x))

scala> b.mapValues("x" + _ + "x").collect

res5: Array[(Int, String)] = Array((3,xdogx), (5,xtigerx), (4,xlionx),(3,xcatx), (7,xpantherx), (5,xeaglex))

15）combineByKey

16）reduceByKey

顧名思義，reduceByKey就是對元素為KV對的RDD中Key相同的元素的Value進行reduce，因此，Key相同的多個元素的值被reduce為一個值，然後與原RDD中的Key組成一個新的KV對。

舉例:

scala> val a = sc.parallelize(List((1,2),(3,4),(3,6)))

scala> a.reduceByKey((x,y) => x + y).collect

res7: Array[(Int, Int)] = Array((1,2), (3,10))

上述例子中，對Key相同的元素的值求和，因此Key為3的兩個元素被轉為了(3,10)。

17）reduce

reduce將RDD中元素兩兩傳遞給輸入函式，同時產生一個新的值，新產生的值與RDD中下一個元素再被傳遞給輸入函式直到最後只有一個值為止。

舉例：對RDD中的元素求和

scala> val c = sc.parallelize(1 to 10)

scala> c.reduce((x, y) => x + y)

res4: Int = 55

18）join

19）zip

20）intersection

intersection

5、Action運算元

1）foreach

2）saveAsTextFile

3）collect

相當於toArray，將分散式的RDD返回為一個單機的Scala Array.

4）count

作者：青禾ws
連結：