摘要: 本文主要介紹Spark算子的作用，以及算子的分類。

轉(zhuǎn)換：Transformation ， 行動(dòng)： Action

RDD算子分類，大致可以分為兩類，即：

1. ?Transformation：轉(zhuǎn)換算子，這類轉(zhuǎn)換并不觸發(fā)提交作業(yè)，完成作業(yè)中間過(guò)程處理。

2. ?Action：行動(dòng)算子，這類算子會(huì)觸發(fā)SparkContext提交Job作業(yè)。

下面分別對(duì)兩類算子進(jìn)行詳細(xì)介紹：

一：Transformation：轉(zhuǎn)換算子

1. ?map：

將原來(lái)RDD的每個(gè)數(shù)據(jù)項(xiàng)通過(guò)map中的用戶自定義函數(shù)f映射轉(zhuǎn)變?yōu)橐粋€(gè)新的元素。源碼中map算子相當(dāng)于初始化一個(gè)RDD，新RDD叫做MappedRDD(this,sc.clean(f) )。即：

map是對(duì)RDD中的每個(gè)元素都執(zhí)行一個(gè)指定的函數(shù)來(lái)產(chǎn)生一個(gè)新的RDD。任何原RDD中的元素在新RDD中都有且只有一個(gè)元素與之對(duì)應(yīng)。

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

a: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[6] at parallelize at :27

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

b: org.apache.spark.rdd.RDD[Int] = MapPartitionsRDD[7] at map at :29

scala> a.collect

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

scala> b.collect

res8: Array[Int] = Array(3, 6, 9, 12, 15, 18, 21, 24, 27)

上述例子中把原RDD中每個(gè)元素都乘以3來(lái)產(chǎn)生一個(gè)新的RDD。

2. ?mapPartitions：

mapPartitions函數(shù)獲取到每個(gè)分區(qū)的迭代器，在函數(shù)中通過(guò)這個(gè)分區(qū)整體的迭代器對(duì)整個(gè)分區(qū)的元素進(jìn)行操作。內(nèi)部實(shí)現(xiàn)是生成MapPartitionsRDD。

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

a: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[10] at parallelize at :27

scala> a.collect

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

scala>varc = a.mapPartitions( a=>a.filter(_>=7) )

c: org.apache.spark.rdd.RDD[Int] = MapPartitionsRDD[11] at mapPartitions at :29

scala> c.collect

res12:Array[Int] =Array(7,8,9)

上述例子是通過(guò)函數(shù)filter對(duì)分區(qū)中所有數(shù)據(jù)進(jìn)行過(guò)濾。

3. ?mapValues

針對(duì)(key,value)型數(shù)據(jù)中的Value進(jìn)行操作，而不對(duì)Key進(jìn)行處理。即：

mapValues顧名思義就是輸入函數(shù)應(yīng)用于RDD中Kev-Value的Value，原RDD中的Key保持不變，與新的Value一起組成新的RDD中的元素。因此，該函數(shù)只適用于元素為KV對(duì)的RDD。

scala> val a = sc.parallelize(List("Hadoop","HBase","Hive","Spark"),2)

a: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[12] at parallelize at :27

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

b: org.apache.spark.rdd.RDD[(Int,String)] = MapPartitionsRDD[13] at map at :29

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

res14:Array[(Int,String)] =Array((6,Hadoop), (5,HBase), (4,Hive), (5,Spark))

4. ?mapWith:

mapWith是map的另外一個(gè)變種，map只需要一個(gè)輸入函數(shù)，而mapWith有兩個(gè)輸入函數(shù)。

eg:?把partition index 乘以10，然后加上2作為新的RDD的元素.(3 是將十個(gè)數(shù)分為三個(gè)區(qū))

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

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

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

5. ?flatMap：

將原來(lái)RDD中的每個(gè)元素通過(guò)函數(shù)f轉(zhuǎn)換為新的元素，并將生成的RDD的每個(gè)集合中的元素合并為一個(gè)集合，內(nèi)部創(chuàng)建FlatMappedRDD(this,sc.clean() )。即：

與map類似，區(qū)別是原RDD中的元素經(jīng)map處理后只能生成一個(gè)元素，而原RDD中的元素經(jīng)flatmap處理后可生成多個(gè)元素來(lái)構(gòu)建新RDD。

eg：對(duì)原RDD中的每個(gè)元素x產(chǎn)生y個(gè)元素（從1到y(tǒng)，y為元素x的值）。

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

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

scala> a.collect

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

scala> b.collect

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

6. ?flatMapWith：

flatMapWith與mapWith很類似，都是接收兩個(gè)函數(shù)，一個(gè)函數(shù)把partitionIndex作為輸入，輸出是一個(gè)新類型A；另外一個(gè)函數(shù)是以二元組（T,A）作為輸入，輸出為一個(gè)序列，這些序列里面的元素組成了新的RDD。

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

scala> a.collect

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

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

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

7. ?flatMapWithValues：

flatMapValues類似于mapValues，不同的在于flatMapValues應(yīng)用于元素為KV對(duì)的RDD中Value。每個(gè)一元素的Value被輸入函數(shù)映射為一系列的值，然后這些值再與原RDD中的Key組成一系列新的KV對(duì)。

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

scala> a.collect

res2: Array[(Int, Int)] = Array((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中每個(gè)元素的值被轉(zhuǎn)換為一個(gè)序列（從其當(dāng)前值到5），比如第一個(gè)KV對(duì)(1,2), 其值2被轉(zhuǎn)換為2，3，4，5。然后其再與原KV對(duì)中Key組成一系列新的KV對(duì)(1,2),(1,3),(1,4),(1,5)。

8. ?reduce：

reduce將RDD中元素兩兩傳遞給輸入函數(shù)，同時(shí)產(chǎn)生一個(gè)新的值，新產(chǎn)生的值與RDD中下一個(gè)元素再被傳遞給輸入函數(shù)直到最后只有一個(gè)值為止。

eg：對(duì)元素求和。

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

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

res5: Int = 55

9. ?reduceByKey

顧名思義，reduceByKey就是對(duì)元素為KV對(duì)的RDD中Key相同的元素的Value進(jìn)行reduce，因此，Key相同的多個(gè)元素的值被reduce為一個(gè)值，然后與原RDD中的Key組成一個(gè)新的KV對(duì)。

eg：對(duì)Key相同的元素的值求和，因此Key為3的兩個(gè)元素被轉(zhuǎn)為了(3,10)。

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

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

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

10. ?cartesian：

對(duì)兩個(gè)RDD內(nèi)的所有元素進(jìn)行笛卡爾積操作(耗內(nèi)存)，內(nèi)部實(shí)現(xiàn)返回CartesianRDD。

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

scala> val b = sc.parallelize(List(4,5,6))

scala> val c = a.cartesian(b)

scala> c.collect

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

11. ?Sample：

sample將RDD這個(gè)集合內(nèi)的元素進(jìn)行采樣，獲取所有元素的子集。用戶可以設(shè)定是否有有放回的抽樣，百分比，隨機(jī)種子，進(jìn)而決定采樣方式。

內(nèi)部實(shí)現(xiàn)： SampledRDD(withReplacement,fraction,seed)。

函數(shù)參數(shù)設(shè)置：

? ????????????withReplacement=true，表示有放回的抽樣。

? ????????????withReplacement=false，表示無(wú)放回的抽樣。

根據(jù)fraction指定的比例，對(duì)數(shù)據(jù)進(jìn)行采樣，可以選擇是否用隨機(jī)數(shù)進(jìn)行替換，seed用于指定隨機(jī)數(shù)生成器種子。

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

scala> a.sample(false,0.1,0).count

res16: Long = 12

scala> a.sample(false,0.1,0).collect

res17: Array[Int] = Array(10, 47, 55, 73, 76, 84, 87, 88, 91, 92, 95, 98)

scala> a.sample(true,0.7,scala.util.Random.nextInt(10000)).count

res19: Long = 75

scala> a.sample(true,0.7,scala.util.Random.nextInt(10000)).collect

res20: Array[Int] = Array(1, 3, 3, 3, 5, 6, 9, 9, 9, 9, 10, 10, 15, 17, 20, 23, 23, 27, 28, 31, 32, 32, 34, 35, 36, 36, 36, 36, 38, 39, 41, 42, 42, 43, 45, 47, 49, 49, 50, 50, 51, 51, 54, 55, 55, 57, 57, 57, 57, 57, 59, 59, 61, 61, 63, 67, 72, 74, 76, 76, 80, 80, 81, 81, 81, 82, 83, 85, 87, 88, 90, 93, 95, 96, 97, 97, 99, 100)

12. ?union:

使用union函數(shù)時(shí)需要保證兩個(gè)RDD元素的數(shù)據(jù)類型相同，返回的RDD數(shù)據(jù)類型和被合并的RDD元素?cái)?shù)據(jù)類型相同。并不進(jìn)行去重操作，保存所有的元素，如果想去重，可以使用distinct()。同時(shí)，spark還提供更為簡(jiǎn)潔的使用union的API，即通過(guò)++符號(hào)相當(dāng)于union函數(shù)操作。

eg： a 與 b 的聯(lián)合

scala> val a = sc.parallelize(List(("A",1),("B",2),("c",3),("A",4),("C",5) ))

scala> val b = sc.parallelize(List(("A",5),("B",6),("A",4),("C",9) ))

scala> a.union(b).collect

res22: Array[(String, Int)] = Array((A,1), (B,2), (c,3), (A,4), (C,5), (A,5), (B,6), (A,4), (C,9))

去重復(fù)：

scala> val d = sc.parallelize(List(("A",5),("B",6),("A",5) ))

scala> d.distinct.collect

res25:Array[(String, Int)] =Array((B,6), (A,5))

13. ?groupBy：

將元素通過(guò)函數(shù)生成相應(yīng)的Key，數(shù)據(jù)就轉(zhuǎn)化為Key-Value格式，之后將Key相同的元素分為一組。

eg：根據(jù)數(shù)據(jù)集中的每個(gè)元素的K值對(duì)數(shù)據(jù)分組

scala> val a = sc.parallelize(List(("A",1),("B",2),("c",3),("A",4),("C",5) ))

scala> a.groupByKey().collect

res21:Array[(String, Iterable[Int])] =Array((B,CompactBuffer(2)), (A,CompactBuffer(1,4)),(C,CompactBuffer(5)), (c,CompactBuffer(3)))

14. ?join：

join對(duì)兩個(gè)需要連接的RDD進(jìn)行cogroup函數(shù)操作，將相同key的數(shù)據(jù)能偶放到一個(gè)分區(qū)，在cgroup操作之后形成新RDD對(duì)每個(gè)key下的元素進(jìn)行笛卡爾積的操作，返回的結(jié)果在展平，對(duì)應(yīng)key下的所有元組形成一個(gè)集合。最后返回 RDD[(K， (V， W))]。

eg：a與b兩個(gè)數(shù)據(jù)連接，相當(dāng)于表的關(guān)聯(lián)

scala> val a = sc.parallelize(List(("A",1),("B",2),("c",3),("A",4),("C",5) ))

scala> val b = sc.parallelize(List(("A",5),("B",6),("A",4),("C",9) ))

scala> a.join(b).collect

res23:Array[(String, (Int, Int))] =Array((B,(2,6)), (A,(1,5)), (A,(1,4)), (A,(4,5)), (A,(4,4)), (C,(5,9)))

15. ?cache：

cache將RDD元素從磁盤緩存到內(nèi)存。相當(dāng)于 persist(MEMORY_ONLY) 函數(shù)的

功能。

16. ?persist：

persist函數(shù)對(duì)RDD進(jìn)行緩存操作，數(shù)據(jù)緩存在哪里，由StorageLevel這個(gè)枚舉類型進(jìn)行確定。DISK 代表磁盤，MEMORY 代表內(nèi)存， SER 代表數(shù)據(jù)是否進(jìn)行序列化存儲(chǔ)。

函數(shù)定義：?persist(newLevel:StorageLevel)

StorageLevel 是枚舉類型，代表存儲(chǔ)模式。

MEMORY_AND_DISK_SER 代表數(shù)據(jù)可以存儲(chǔ)在內(nèi)存和磁盤，并且以序列化的方式存儲(chǔ)，其他同理。

二：Action：行動(dòng)算子

1. ?foreach：

foreach對(duì)RDD中的每個(gè)元素都應(yīng)用f函數(shù)操作，不返回 RDD 和 Array， 而是返回Uint。

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

scala> a.foreach(println(_))

4

5

6

7

8

9

1

2

3

2. ?saveAsTextFile：

函數(shù)將數(shù)據(jù)輸出，存儲(chǔ)到 HDFS 的指定目錄。

函數(shù)的內(nèi) 部實(shí)現(xiàn)，其內(nèi)部通過(guò)調(diào)用 saveAsHadoopFile 進(jìn)行實(shí)現(xiàn)：

this.map(x => (NullWritable.get(), new Text(x.toString)))

.saveAsHadoopFile[TextOutputFormat[NullWritable, Text]](path)

將 RDD 中的每個(gè)元素映射轉(zhuǎn)變?yōu)?(null， x.toString)，然后再將其寫入 HDFS。

3. ?collect：

collect相當(dāng)于toArray，不過(guò)已經(jīng)過(guò)時(shí)不推薦使用，collect將分布式的RDD返回為一個(gè)單機(jī)的scala Array數(shù)據(jù)，在這個(gè)數(shù)組上運(yùn)用 scala 的函數(shù)式操作。

4. ?count：

count返回整個(gè)RDD的元素個(gè)數(shù)。

scala> val a = sc.parallelize(1to10)

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

scala> a.countres10:Long=10