Spark学习（二） ： 常见RDD操作

首先是任何数据类型都支持的操作：

1，针对各个元素的转化操作

(1) map() 和 filter()

map() :接受一个函数，把函数用于RDD中的每个元素，将函数的返回结果作为结果RDD中对应元素的值。

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

scala> val result = input.map(x => x * x)
result: org.apache.spark.rdd.RDD[Int] = MapPartitionsRDD[1] at map at <console>:30

scala> println(result.collect().mkString(","))
1,4,9,16

map函数并不需要返回值和输入类型一样。

fitter() :同map()一样，接受一个函数，并将RDD中满足该函数的元素放入新的RDD中。

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

scala> val result = input.filter(x => x!=1)
result: org.apache.spark.rdd.RDD[Int] = MapPartitionsRDD[3] at filter at <console>:30

scala> println(result.collect().mkString(","))
2,3,4

flatMap()函数：对每个输入实现多个输出元素，不过得到的是可访问的所有元素的RDD.

将数据切分为单词

scala> val lines = sc.parallelize(List("hello world","hi"))
lines: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[4] at parallelize at <console>:29

scala> val words = lines.flatMap(line => line.split(" "))
words: org.apache.spark.rdd.RDD[String] = MapPartitionsRDD[5] at flatMap at <console>:30

scala> println(words.collect().mkString(","))
hello,world,hi

2.集合操作(同类型RDD操作)

RDD.distinct() : 将元素中重复的元素去掉，不过需要注意distinct()操作开销很大，因为它需要将所有数据通过网路进行混洗，以确保每个元素都只有一份。

RDD.union(other) : 返回一个包含两个RDD的所有元素的RDD,如果输入的RDD中有重复数据，将不会自动去重。

RDD.intersection(other) :只返回两个RDD中都有的元素，会自动去重，因此需要混洗操作，开销比较大。

RDD.cartesian(other) :计算两个RDD的笛卡尔积。

RDD.sample(withReplacement,fraction,[seed]) : 对RDD采样，以及是否替换   ，例如：rdd.sample(false,0.5) 输出：非确定的

3.行动操作。

RDD.reduce() : 接受一个函数作为参数，这个函数要操作两个相同元素类型的RDD数据并返回同一个同样类型的新元素，需要注意是对每一个分区的结果继续同样的函数操作，可以方便的计算出RDD中所有元素的总和，元素个数，以及其他类型的聚合操作。

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

scala> val sum = input.reduce((x,y)=>x+y)
sum: Int = 10

RDD.fold() ：与redce()类似，再加上一个“初始值”来作为每个分区第一个调用时的结果。你所提供的初始值应当是你提供操作的单位元素。也就是说对每个初始值进行多次计算不会改变结果，例如+ 对应0.*对应1.拼接对应空列表。

RDD.aggregate() : 返回值类型和所操作的RDD类型不需要相同，同时需要提供初始值，通过一个函数把RDD中的每个分区元素合并起来放入累加器。考虑到每个节点是在本地进行累加的，最终，还需要提供第二个函数来将累加器两两合并。例如：求平均数

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

scala> val result = input.aggregate(0,0) (
     | (acc,value) => (acc._1+value,acc._2+1),
     | (acc1,acc2) => (acc1._1+acc2._1,acc1._2+acc2._2))
result: (Int, Int) = (10,4)

scala> val avg = result._1/result._2.toDouble
avg: Double = 2.5

RDD.collect() :返回RDD中所有元素，要求数据都必须能一同放入单台机器的内存中。

scala> input.collect()
res3: Array[Int] = Array(1, 2, 3, 4)

RDD.count() :返回RDD中的元素个数。

scala> input.count()
res4: Long = 4

RDD.countByValue() : 个元素在RDD中出现的次数。

RDD.take(num) ： 从元素中返回num个元素

scala> input.take(2)
res7: Array[Int] = Array(1, 2)

RDD.top() :返回对前面的num个元素

RDD.takeOrdered(num)(ordering) : 从RDD中返回按照提供的顺序返回前面的num个元素

RDD.foreaceh(func) : 对RDD中每个元素使用给定的函数 

如前所述，Spark RDD是惰性求值，有时希望多次使用同一个同一个RDD,而不希望重复运算的到该RDD,可以将该RDD持久化。持久化是会计算出RDD的节点会分别保存它们求出的分区数据，如果分区数据遭到破环，Spark会重新计算丢失的数据分区。同时持久化有不同的等级。

详细可以看如下文章：http://www.ccblog.cn/102.htm