Spark算子（二）Action

1.1.1 Action

reduce（func）:通过function 函数聚合RDD中的所有元素，

　　　　　　　　RDD必须是可交换且可并联的

 1 scala> val rdd1 = sc.makeRDD(1 to 10,2)
 2 rdd1: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[85] at makeRDD at <console>:24
 3 
 4 scala> rdd1.reduce(_+_)
 5 res50: Int = 55
 6 
 7 scala> val rdd2 = sc.makeRDD(Array(("a",1),("a",3),("c",3),("d",5)))
 8 rdd2: org.apache.spark.rdd.RDD[(String, Int)] = ParallelCollectionRDD[86] at makeRDD at <console>:24
 9 
10 scala> rdd2.reduce((x,y)=>(x._1 + y._1,x._2 + y._2))
11 res51: (String, Int) = (adca,12)

collect ()　　：在驱动程序中，以数组的形式返回数据集的所有元素

　　将分布式的RDD返回为一个单机的 scala Array 数组。

　　在这个数组上运用 Scala 的函数式操作。

　　通过函数操作，将结果返回到 Driver 程序所在的节点，以数组形式存储。

count()	返回RDD的元素个数
first()	返回RDD的第一个元素（类似于take(1)）
take(n)	返回一个由数据集的前n个元素组成的数组
takeSample(withReplacement,num, [seed])	返回一个数组，该数组由从数据集中随机采样的num个元素组成，可以选择是否用随机数替换不足的部分，seed用于指定随机数生成器种子
takeOrdered(n)&top(n)	返回前几个的排序(小到大)&（大到小）

aggregate (zeroValue: U)(seqOp: (U, T) ⇒ U, combOp: (U, U) ⇒ U)

aggregate函数将每个分区里面的元素通过seqOp和初始值进行聚合，然后用combine函数将每个分区的结果和初始值(zeroValue)进行combine操作。这个函数最终返回的类型不需要和RDD中元素类型一致。

 1 scala> var rdd1 = sc.makeRDD(1 to 10,2)
 2 rdd1: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[88] at makeRDD at <console>:24
 3 
 4 scala> rdd1.aggregate(1)(
 5      | {(x : Int,y : Int) => x + y},
 6      | {(a : Int,b : Int) => a + b}
 7      | )
 8 res56: Int = 58
 9 
10 scala> rdd1.aggregate(1)(
11      | {(x : Int,y : Int) => x * y},
12      | {(a : Int,b : Int) => a + b}
13      | )
14 res57: Int = 30361

aggregate（）（）

fold(num)(func)　　：折叠操作，aggregate的简化操作，seqop和combop一样。

 1 scala> var rdd1 = sc.makeRDD(1 to 4,2)
 2 rdd1: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[90] at makeRDD at <console>:24
 3 
 4 scala> rdd1.aggregate(1)(
 5      | {(x : Int,y : Int) => x + y},
 6      | {(a : Int,b : Int) => a + b}
 7      | )
 8 res59: Int = 13
 9 
10 scala> rdd1.fold(1)(_+_)
11 res60: Int = 13

fold【aggregate的简化】

saveAsTextFile(path)：	将数据集的元素以textfile的形式保存到HDFS文件系统或者其他支持的文件系统，对于每个元素，Spark将会调用toString方法，将它装换为文件中的文本
saveAsSequenceFile(path)	将数据集中的元素以Hadoop sequencefile的格式保存到指定的目录下，可以使HDFS或者其他Hadoop支持的文件系统。
saveAsObjectFile(path)	用于将RDD中的元素序列化成对象，存储到文件中。

countByKey() ：

针对(K,V)类型的RDD，返回一个(K,Int)的map，表示每一个key对应的元素个数。

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

countByKey

foreach(func)：

在数据集的每一个元素上，运行函数func进行更新。

　对RDD中的每一个元素都应用 f 函数操作。不返回RDD和Array，而是返回 Unit。

 1 scala> var rdd = sc.makeRDD(1 to 10,2)
 2 rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[107] at makeRDD at <console>:24
 3 
 4 scala> var sum = sc.accumulator(0)
 5 warning: there were two deprecation warnings; re-run with -deprecation for details
 6 sum: org.apache.spark.Accumulator[Int] = 0
 7 
 8 scala> rdd.foreach(sum+=_)
 9 
10 scala> sum.value
11 res68: Int = 55
12 
13 scala> rdd.collect().foreach(println)
14 1
15 2
16 3
17 4
18 5
19 6
20 7
21 8
22 9
23 10

foreach(func)

1.1.2 数值RDD的统计操作

方法	含义
count（）	RDD中的元素个数
mean（）	元素的平均值
sum（）	总和
max（）	最大值
min（）	最小值
variance（）	元素的方差
samplezVariance	从采样中计算出的方差
stdev（）	标准差
sampleStdev（）	采样的标准差