RDD基本操作（下）

上一篇里我提到可以把RDD当作一个数组，这样我们在学习spark的API时候很多问题就能很好理解了。上篇文章里的API也都是基于RDD是数组的数据模型而进行操作的。

　　Spark是一个计算框架，是对mapreduce计算框架的改进，mapreduce计算框架是基于键值对也就是map的形式，之所以使用键值对是人们发现世界上大部分计算都可以使用map这样的简单计算模型进行计算。但是Spark里的计算模型却是数组形式，RDD如何处理Map的数据格式了？本篇文章就主要讲解RDD是如何处理Map的数据格式。

　　Pair RDD及键值对RDD，Spark里创建Pair RDD也是可以通过两种途径，一种是从内存里读取，一种是从文件读取。

　　首先是从文件读取，上篇里我们看到使用textFile方法读取文件，读取的文件是按行组织成一个数组，要让其变成map格式就的进行转化，代码如下所示：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

/*

 * 测试文件数据:

 * x01,1,4

   x02,11,1

x01,3,9

x01,2,6

   x02,18,12

   x03,7,9

 *

 * */

val rddFile:RDD[(String,String)]= sc.textFile("file:///F:/sparkdata01.txt",1).map { x => (x.split(",")(0),x.split(",")(1) + "," + x.split(",")(2)) }

val rFile:RDD[String]= rddFile.keys

println("=========createPairMap File=========")

println(rFile.collect().mkString(","))// x01,x02,x01,x01,x02,x03

println("=========createPairMap File=========")

　　我们由此可以看到以读取文件方式构造RDD，我们需要使用map函数进行转化，让其变成map的形式。

　　下面是通过内存方式进行创建，代码如下：

1

2

3

4

5

val rdd:RDD[(String,Int)]= sc.makeRDD(List(("k01",3),("k02",6),("k03",2),("k01",26)))

val r:RDD[(String,Int)]= rdd.reduceByKey((x,y)=> x + y)

println("=========createPairMap=========")

println(r.collect().mkString(","))// (k01,29),(k03,2),(k02,6)

println("=========createPairMap=========")

　　RDD任然是数组形式，只不过数组的元素是("k01",3)格式是scala里面特有的Tuple2及二元组，元组可以当作一个集合，这个集合可以是各种不同数据类型组合而成，二元组就是只包含两个元素的元组。

　　由此可见Pair RDD也是数组，只不过是一个元素为二元组的数组而已，上篇里对RDD的操作也是同样适用于Pair RDD的。

　　下面是Pair RDD的API讲解，同样我们先说转化操作的API：

1

2

3

4

5

6

7

8

9

10

11

12

13

reduceByKey：合并具有相同键的值；

groupByKey：对具有相同键的值进行分组；

keys：返回一个仅包含键值的RDD；

values：返回一个仅包含值的RDD；

sortByKey：返回一个根据键值排序的RDD；

flatMapValues：针对Pair RDD中的每个值应用一个返回迭代器的函数，然后对返回的每个元素都生成一个对应原键的键值对记录；

mapValues：对Pair RDD里每一个值应用一个函数，但是不会对键值进行操作；

combineByKey：使用不同的返回类型合并具有相同键的值；

subtractByKey：操作的RDD我们命名为RDD1，参数RDD命名为参数RDD，剔除掉RDD1里和参数RDD中键相同的元素；

join：对两个RDD进行内连接；

rightOuterJoin：对两个RDD进行连接操作，第一个RDD的键必须存在，第二个RDD的键不再第一个RDD里面有那么就会被剔除掉，相同键的值会被合并；

leftOuterJoin：对两个RDD进行连接操作，第二个RDD的键必须存在，第一个RDD的键不再第二个RDD里面有那么就会被剔除掉，相同键的值会被合并；

cogroup：将两个RDD里相同键的数据分组在一起

　　下面就是行动操作的API了，具体如下：

1

2

3

countByKey：对每个键的元素进行分别计数；

collectAsMap：将结果变成一个map；

lookup：在RDD里使用键值查找数据

　　接下来我再提提那些不是很常用的RDD操作，具体如下：

　　转化操作的：

1

sample:对RDD采样；

　　行动操作：

1

2

3

4

5

take(num):返回RDD里num个元素，随机的；

top(num):返回RDD里最前面的num个元素，这个方法实用性还比较高；

takeSample：从RDD里返回任意一些元素；

sample：对RDD里的数据采样；

takeOrdered：从RDD里按照提供的顺序返回最前面的num个元素

　　接下来就是示例代码了，如下所示：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

package cn.com.sparktest

 

import org.apache.spark.SparkConf

import org.apache.spark.SparkConf

import org.apache.spark.SparkContext

import org.apache.spark.SparkContext._

import org.apache.spark.rdd.RDD

import org.apache.spark.util.collection.CompactBuffer

 

object SparkPairMap {

   

  valconf:SparkConf= newSparkConf().setAppName("spark pair map").setMaster("local[2]")

  valsc:SparkContext= newSparkContext(conf)

  

  /**

   * 构建Pair RDD

   */

  defcreatePairMap():Unit= {

    valrdd:RDD[(String,Int)]= sc.makeRDD(List(("k01",3),("k02",6),("k03",2),("k01",26)))

    valr:RDD[(String,Int)]= rdd.reduceByKey((x,y)=> x + y)

    println("=========createPairMap=========")

    println(r.collect().mkString(","))// (k01,29),(k03,2),(k02,6)

    println("=========createPairMap=========")

     

    /*

     * 测试文件数据:

     * x01,1,4

             x02,11,1

             x01,3,9

             x01,2,6

       x02,18,12

       x03,7,9

     *

     * */

    valrddFile:RDD[(String,String)]= sc.textFile("file:///F:/sparkdata01.txt",1).map { x => (x.split(",")(0),x.split(",")(1) + "," + x.split(",")(2)) }

    valrFile:RDD[String]= rddFile.keys

    println("=========createPairMap File=========")

    println(rFile.collect().mkString(","))// x01,x02,x01,x01,x02,x03

    println("=========createPairMap File=========")

  }

   

  /**

   * 关于Pair RDD的转化操作和行动操作

   */

  defpairMapRDD(path:String):Unit= {

    valrdd:RDD[(String,Int)]= sc.makeRDD(List(("k01",3),("k02",6),("k03",2),("k01",26)))

    valother:RDD[(String,Int)]= sc.parallelize(List(("k01",29)),1)

     

    // 转化操作

    valrddReduce:RDD[(String,Int)]= rdd.reduceByKey((x,y)=> x + y)

    println("====reduceByKey===:"+ rddReduce.collect().mkString(","))// (k01,29),(k03,2),(k02,6)

    valrddGroup:RDD[(String,Iterable[Int])]= rdd.groupByKey()

    println("====groupByKey===:"+ rddGroup.collect().mkString(","))// (k01,CompactBuffer(3, 26)),(k03,CompactBuffer(2)),(k02,CompactBuffer(6))

    valrddKeys:RDD[String]= rdd.keys

    println("====keys=====:"+ rddKeys.collect().mkString(","))// k01,k02,k03,k01

    valrddVals:RDD[Int]= rdd.values

    println("======values===:"+ rddVals.collect().mkString(","))// 3,6,2,26

    valrddSortAsc:RDD[(String,Int)]= rdd.sortByKey(true,1)

    valrddSortDes:RDD[(String,Int)]= rdd.sortByKey(false,1)

    println("====rddSortAsc=====:"+ rddSortAsc.collect().mkString(","))// (k01,3),(k01,26),(k02,6),(k03,2)

    println("======rddSortDes=====:"+ rddSortDes.collect().mkString(","))// (k03,2),(k02,6),(k01,3),(k01,26)

    valrddFmVal:RDD[(String,Int)]= rdd.flatMapValues { x=> List(x + 10) }

    println("====flatMapValues===:"+ rddFmVal.collect().mkString(","))// (k01,13),(k02,16),(k03,12),(k01,36)

    valrddMapVal:RDD[(String,Int)]= rdd.mapValues { x=> x + 10 }

    println("====mapValues====:"+ rddMapVal.collect().mkString(","))// (k01,13),(k02,16),(k03,12),(k01,36)

    valrddCombine:RDD[(String,(Int,Int))]= rdd.combineByKey(x=> (x,1), (param:(Int,Int),x)=> (param._1+ x,param._2+ 1), (p1:(Int,Int),p2:(Int,Int))=> (p1._1+ p2._1,p1._2+ p2._2))

    println("====combineByKey====:"+ rddCombine.collect().mkString(","))//(k01,(29,2)),(k03,(2,1)),(k02,(6,1))

    valrddSubtract:RDD[(String,Int)]= rdd.subtractByKey(other);

    println("====subtractByKey====:"+ rddSubtract.collect().mkString(","))// (k03,2),(k02,6)

    valrddJoin:RDD[(String,(Int,Int))]= rdd.join(other)

    println("=====rddJoin====:"+ rddJoin.collect().mkString(","))// (k01,(3,29)),(k01,(26,29))

    valrddRight:RDD[(String,(Option[Int],Int))]= rdd.rightOuterJoin(other)

    println("====rightOuterJoin=====:"+ rddRight.collect().mkString(","))// (k01,(Some(3),29)),(k01,(Some(26),29))

    valrddLeft:RDD[(String,(Int,Option[Int]))]= rdd.leftOuterJoin(other)

    println("=====rddLeft=====:"+ rddLeft.collect().mkString(","))// (k01,(3,Some(29))),(k01,(26,Some(29))),(k03,(2,None)),(k02,(6,None))

    valrddCogroup: RDD[(String, (Iterable[Int], Iterable[Int]))] =rdd.cogroup(other)

    println("=====cogroup=====:"+ rddCogroup.collect().mkString(","))// (k01,(CompactBuffer(3, 26),CompactBuffer(29))),(k03,(CompactBuffer(2),CompactBuffer())),(k02,(CompactBuffer(6),CompactBuffer()))

     

    // 行动操作

    valresCountByKey =rdd.countByKey()

    println("=====countByKey=====:"+ resCountByKey)// Map(k01 -> 2, k03 -> 1, k02 -> 1)

    valresColMap = rdd.collectAsMap()

    println("=====resColMap=====:"+ resColMap)//Map(k02 -> 6, k01 -> 26, k03 -> 2)

    valresLookup = rdd.lookup("k01")

    println("====lookup===:"+ resLookup) // WrappedArray(3, 26)

  }

   

  /**

   * 其他一些不常用的RDD操作

   */

  defotherRDDOperate(){

    valrdd:RDD[(String,Int)]= sc.makeRDD(List(("k01",3),("k02",6),("k03",2),("k01",26)))

     

    println("=====first=====:"+ rdd.first())//(k01,3)

    valresTop = rdd.top(2).map(x=> x._1+ ";" + x._2)

    println("=====top=====:"+ resTop.mkString(","))// k03;2,k02;6

    valresTake = rdd.take(2).map(x=> x._1+ ";" + x._2)

    println("=======take====:"+ resTake.mkString(","))// k01;3,k02;6

    valresTakeSample =rdd.takeSample(false,2).map(x => x._1+ ";" + x._2)

    println("=====takeSample====:"+ resTakeSample.mkString(","))// k01;26,k03;2

    valresSample1 = rdd.sample(false,0.25)

    valresSample2 = rdd.sample(false,0.75)

    valresSample3 = rdd.sample(false,0.5)

    println("=====sample======:"+ resSample1.collect().mkString(","))// 无

    println("=====sample======:"+ resSample2.collect().mkString(","))// (k01,3),(k02,6),(k01,26)

    println("=====sample======:"+ resSample3.collect().mkString(","))// (k01,3),(k01,26)

  }

   

  defmain(args: Array[String]): Unit = {

    createPairMap()

    pairMapRDD("file:///F:/sparkdata01.txt")

    otherRDDOperate()

  }

   

}

　　本篇到此就将我知道的spark的API全部讲完了，两篇文章里的示例代码都是经过测试的，可以直接运行，大家在阅读代码时候最好注意这个特点：我在写RDD转化代码时候都是很明确的写上了转化后的RDD的数据类型，这样做的目的就是让读者更加清晰的认识不同RDD转化后的数据类型，这点在实际开发里非常重要，在实际的计算里我们经常会不同的计算算法不停的转化RDD的数据类型，而使用scala开发spark程序时候，我发现scala和javascript很类似，我们不去指定返回值数据类型，scala编译器也会自动推算结果的数据类型，因此编码时候我们可以不指定具体数据类型。这个特点就会让我们在实际开发里碰到种种问题，因此我在示例代码里明确了RDD转化后的数据类型。

　　在使用Pair RDD时候，我们要引入：

1

import org.apache.spark.SparkContext._

　　否则代码就有可能报错，说找不到对应的方法，这个引入就是scala里导入的隐世类型转化的功能，原理和上段文字说到的内容差不多。

      开发spark程序不仅仅只可以使用scala，还可以使用python，java，不过scala使用起来更加方便，spark的API简单清晰，这样的编程大大降低了原先使用mapreduce编程的难度，但是如果我们要深入掌握这些API那么就要更加深入的学习下scala。下一篇我就根据spark里RDD的API讲解一些scala的语法，通过这些语法让我们更好的掌握Spark的API。