Spark--RDD常用方法

Spark 计算框架为了能够进行高并发和高吞吐的数据处理，封装了三大数据结构，用于处理不同的应用场景。三大数据结构分别是：
➢ RDD : 弹性分布式数据集
➢ 累加器：分布式共享只写变量
➢ 广播变量：分布式共享只读变量

RDD（Resilient Distributed Dataset）叫做弹性分布式数据集，是 Spark 中最基本的数据处理模型。RDD负责数据的处理以及数据的分区，分发给不同的Executor执行。所以说编写spark任务即是编写RDD数据处理过程。

RDD 的创建

val sparkConf = new SparkConf().setMaster("local[*]").setAppName("spark")
val sparkContext = new SparkContext(sparkConf)

// 从集合创建
val rdd1: RDD[Int] = sparkContext.parallelize(List(1,2,3,4))
val rdd2: RDD[Int] = sparkContext.makeRDD(List(1,2,3,4))

// 从文件创建
val filerdd: RDD[String] = sparkContext.textFile("input")

// 创建RDD时也可以指定RDD的并行度
val dataRDD: RDD[Int] = sparkContext.makeRDD(List(1, 2, 3, 4), 2)
val fileRDD: RDD[String] = sparkContext.textFile("input", 2)

RDD常用方法

// map方法 将处理的数据逐条进行映射转换，这里的转换可以是类型的转换，也可以是值的转换。
val dataRDD1: RDD[Int] = dataRDD.map(num => {num * 2} )
val dataRDD2: RDD[String] = dataRDD.map(num => {"" + num} )

//mapPartitions方法 该方法类似于批处理，参数datas为分区内所以数据，该值为一个RDD
val dataRDD3: RDD[Int] = dataRDD.mapPartitions(datas => {datas.filter(_==2)} )
//mapPartitionsWithIndex方法 作用类似于mapPartitions方法，参数多了一个分区下标
val dataRDD4 = dataRDD.mapPartitionsWithIndex((index, datas) => {datas.map((index, _))} )

//flatmap方法 将处理的数据进行映射处理后进行扁平化处理
val dataRDD5: RDD[List[Int]] = sparkContext.makeRDD(List(List(1, 2), List(3, 4)), 1)
val dataRDD6: RDD[Int] = dataRDD5.flatMap(list => list)

//glom方法 将同一个分区的数据直接转换为相同类型的内存数组进行处理，分区不变
val dataRDD7:RDD[Array[Int]] = dataRDD.glom()

//groupBy方法 将数据根据指定的规则进行分组, 分区默认不变，但是数据会被打乱重新组合，我们将这样的操作称之为 shuffle。一个组的数据在一个分区中，一个分区中可以有多个组
val dataRDD8: RDD[(Int, Iterable[Int])] = dataRDD.groupBy(_%2)

//filter方法 将数据根据指定的规则进行筛选过滤，符合规则的数据保留，不符合规则的数据丢弃。
val dataRDD9 = dataRDD.filter(_%2 == 0)

//sample方法 从集合中抽取样本 参数列表（抽取的数据是否放回,抽取的几率,随机数种子）
val dataRDD10 = dataRDD.sample(false, 0.5)

//distinct方法 将数据集中重复的数据去重
val dataRDD11 = dataRDD.distinct()

//coalesce方法  根据数据量缩减分区，用于大数据集过滤后，提高小数据集的执行效率
val dataRDD12 = dataRDD.coalesce(numPartitions = 2)

//repartition方法 对集合中的数据重新分区 进行 shuffle 过程
val dataRDD13 = dataRDD.repartition(4)

//sortBy方法 排序数据，参数列表（排序值,是否升序,分区数） 中间存在 shuffle 的过程
val dataRDD14 = dataRDD.sortBy(num=>num, false, 1)

//reduce方法 聚集 RDD 中的所有元素，先聚合分区内数据，再聚合分区间数据
val reduce: Int = dataRDD.reduce(_ + _)

//collect方法 以数组 Array 的形式返回数据集的所有元素
val array: Array[Int] = dataRDD.collect()

//count方法 返回 RDD 中元素的个数
val count: Long = dataRDD.count()

//first方法 返回 RDD 中的第一个元素
val value: Int = dataRDD.first()

//take方法 返回一个由 RDD 的前 n 个元素组成的数组
val ints: Array[Int] = dataRDD.take(4)

//takeOrdered方法 返回该 RDD 排序后的前 n 个元素组成的数组
val ints1 = dataRDD.takeOrdered(4)

//aggregate方法  将数据根据不同的规则进行分区内计算和分区间计算
// aggregate 算子是函数柯里化，存在两个参数列表
// 1. 第一个参数列表中的参数表示初始值
// 2. 第二个参数列表中含有两个参数
// 2.1 第一个参数表示分区内的计算规则
// 2.2 第二个参数表示分区间的计算规则
val value2: Int = dataRDD.aggregate(0)(_ + _, _ + _)

//折叠操作，aggregate 的简化版操作
val value3 = dataRDD.fold(0)(_ + _)

//foreach方法 分布式遍历 RDD 中的每一个元素，调用指定函数
dataRDD.foreach(println)

/**
 * RDD集合中的数据保存方法
 */
//保存成 Text 文件
dataRDD.saveAsTextFile("output")

//序列化成对象保存到文件
dataRDD.saveAsObjectFile("output1")

// 保存成 Sequencefile 文件
dataRDD.map((_,1)).saveAsSequenceFile("output2")

/**
* RDD集合之间的操作方法
*/
val dataRDD20 = sparkContext.makeRDD(List(1,2,3,4))
val dataRDD21 = sparkContext.makeRDD(List(3,4,5,6))

//intersection方法 求交集后返回一个新的 RDD
val dataRDD22 = dataRDD20.intersection(dataRDD21)

//union方法 求并集后返回一个新的 RDD
val dataRDD23 = dataRDD20.union(dataRDD21)

//subtract方法 求差集
val dataRDD24 = dataRDD20.subtract(dataRDD21)

//zip方法 将两个 RDD 中的元素，以键值对的形式进行合并
val dataRDD25 = dataRDD20.zip(dataRDD21)

/**
* 当 RDD集合中的元素为二元组时
* (K,V)
*/
val dataRDD30: RDD[(String, Int)] = sparkContext.makeRDD(List(("a",1),("b",2),("c",3),("a",4)))

//reduceByKey方法 把Key相同的元素聚集到一起
val dataRDD31: RDD[(String, Int)] = dataRDD30.reduceByKey(_+_)
val dataRDD32: RDD[(String, Int)] = dataRDD30.reduceByKey(_+_, numPartitions = 2)

//groupByKey方法 将数据源的数据根据 key 对 value 进行分组
val dataRDD33 = dataRDD30.groupByKey()

//aggregateByKey方法 将数据根据不同的规则进行分区内计算和分区间计算
// aggregateByKey 算子是函数柯里化，存在两个参数列表
// 1. 第一个参数列表中的参数表示初始值
// 2. 第二个参数列表中含有两个参数
// 2.1 第一个参数表示分区内的计算规则
// 2.2 第二个参数表示分区间的计算规则
val dataRDD34 = dataRDD30.aggregateByKey(0)(_+_,_+_)

//当分区内计算规则和分区间计算规则相同时，aggregateByKey 就可以简化为 foldByKey
val dataRDD35 = dataRDD30.foldByKey(0)(_+_)

//combineByKey方法 最通用的对 key-value 型 rdd 进行聚集操作的聚集函数（aggregation function），
// 1. 第一个参数表示第一个值计算规则
// 2. 第二个参数表示分区内的计算规则
// 3. 第三个参数表示分区间的计算规则
val combineRdd = dataRDD30.combineByKey(
    c => c,
    (c: Int, v) => c + v,
    (c1: Int, c2: Int) => c1 + c2
)

//sortByKey方法 在一个(K,V)的 RDD 上调用，K 必须实现 Ordered 接口(特质)，返回一个按照 key 进行排序的RDD
val dataRDD36: RDD[(String, Int)] = dataRDD30.sortByKey()

//countByKey方法 统计每种 key 的个数
val stringToLong: Map[String, Long] = dataRDD30.countByKey()

/**
 * 集合元素为二元组RDD之间操作方法
 */
val rdd1: RDD[(Int, String)] = sparkContext.makeRDD(Array((1, "a"), (2, "b"), (3, "c"), (4, "d")))
val rdd2: RDD[(Int, Int)] = sparkContext.makeRDD(Array((1, 4), (2, 5), (3, 6), (5, 8)))

//join连接操作 返回一个相同 key 对应的所有元素连接在一起的 (K,(V1,V2))的 RDD
val rdd3:RDD[(Int, (String, Int))] = rdd1.join(rdd2)

//左外连接操作
val rdd4: RDD[(Int, (String, Option[Int]))] = rdd1.leftOuterJoin(rdd2)

//全连接
val rdd5: RDD[(Int, (Iterable[String], Iterable[Int]))] = rdd1.cogroup(rdd2)