Spark-RDD编程（二）

Spark-RDD编程（一）

2.2行动操作（action）

2.2.1 reduce(func)

通过func函数聚集RDD中的所有元素，这个功能必须是可交换且可并联的

    //创建rdd
    val rdd1: RDD[Int] = sc.makeRDD(1 to 10, 2)
    //"_"代表一个占位符，用于表示一个函数的参数
    //这里表示对rdd1中的所有元素进行加法操作
    val res1: Int = rdd1.reduce(_ + _)
    println(res1) //输出  55

    val rdd2: RDD[(String, Int)] = sc.makeRDD(Array(("a", 1), ("b", 2), ("c", 3), ("d", 4)))
    //对rdd2的key和value分别进行聚合
    val res2: (String, Int) = rdd2.reduce((x, y) => (x._1 + y._1, x._2 + y._2))
    println(res2) //输出  (abcd,10)

2.2.2 collect()

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

    //创建rdd
    val rdd: RDD[Int] = sc.makeRDD(1 to 5)
    //返回Array数组
    val arr: Array[Int] = rdd.collect()
    println(arr.toBuffer) //ArrayBuffer(1, 2, 3, 4, 5)

2.2.3  take(n)   takeOrdered(n)

take(n) :返回一个由数据集的前n个元素组成的数组

takeOrdered(n):返回前几个的排序

    //创建rdd
    val rdd: RDD[Int] = sc.makeRDD(Array(4,5,2,1,3))
    //返回由rdd的前3个元素组成的数组Array数组
    val arr1: Array[Int] = rdd.take(3)
    println(arr1.toBuffer)      //ArrayBuffer(4, 5, 2)

    //返回由rdd排序后的前3个元素组成的Array数组
    val arr2: Array[Int] = rdd.takeOrdered(3)
    println(arr2.toBuffer)      //ArrayBuffer(1, 2, 3)

2.2.4 saveAsTextFile(path)

将数据集的元素以textfile的形式保存到HDFS文件系统或者其他支持的文件系统，对于每个元素，Spark将会调用toString方法，将它装换为文件中的文本

2.2.5 saveAsSequenceFile(path) 

将数据集中的元素以Hadoop sequencefile的格式保存到指定的目录下，可以使HDFS或者其他Hadoop支持的文件系统。

2.2.6 saveAsObjectFile(path) 

用于将RDD中的元素序列化成对象，存储到文件中。

2.2.7  countByKey()

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

    //创建rdd
    val rdd = sc.parallelize(List((1,3),(1,2),(1,4),(2,3),(3,6),(3,8)),3)
    //key为 1 的 元组总有3个，所以结果为 1 -> 3
    println(rdd.countByKey())  //Map(3 -> 2, 1 -> 3, 2 -> 1)

2.2.8 foreach(func)

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

import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
 
object RDDAction {
 
  def main(args: Array[String]): Unit = {
    // 创建SparkContext对象
    val conf = new SparkConf()
    conf.setAppName("spark core rdd transform").setMaster("local")
    val sc = new SparkContext(conf)
 
    //通过并行集合创建 RDD 对象
    val arr: Array[Int] = Array(1,2,3,4,5)
    val rdd: RDD[Int] = sc.parallelize(arr)
 
    val size: Long = rdd.count()
 
    val nums: Array[Int] = rdd.collect()
 
    val value: Int = rdd.first()
 
    val res: Array[Int] = rdd.take(3)
 
    val sum: Int = rdd.reduce((v1, v2) => v1 + v2)
    
    println("size = " + size)
    println("The all elements are ")
    nums.foreach(println)
    println("The first element in rdd is " + value)
    println("The first three elements are ")
    res.foreach(println)
    println("sum is " + sum)
    rdd.foreach(print)
    //关闭SparkContext
    sc.stop()
  }
 
}

//运行结果
size = 5
The all elements are 
1
2
3
4
5
The first element in rdd is 1
The first three elements are 
1
2
3
sum is 15
12345
Process finished with exit code 0