spark-core rdd转换算子
一、单值类型
1、map(f) 映射转换
➢ 函数签名
def map[U: ClassTag](f: T => U): RDD[U] ➢ 函数说明
将处理的数据逐条进行映射转换，这里的转换可以是类型的转换，也可以是值的转换。
val dataRDD: RDD[Int] = sparkContext.makeRDD(List(1,2,3,4))
val dataRDD1: RDD[Int] = dataRDD.map(num => {num * 2})
val dataRDD2: RDD[String] = dataRDD1.map(num => {"" + num} )2、mapPartitions(f) 分区
➢ 函数签名
def mapPartitions[U: ClassTag](
f: Iterator[T] => Iterator[U],
preservesPartitioning: Boolean = false): RDD[U]
➢ 函数说明
将待处理的数据以分区为单位发送到计算节点进行处理，这里的处理是指可以进行任意的处
理，哪怕是过滤数据。
val dataRDD1: RDD[Int] = dataRDD.mapPartitions(datas => {datas.filter(_==2)} )3、mapPartitionsWithIndex() 当前分区索引
➢ 函数签名
def mapPartitionsWithIndex[U: ClassTag](
f: (Int, Iterator[T]) => Iterator[U],
preservesPartitioning: Boolean = false): RDD[U]
➢ 函数说明
将待处理的数据以分区为单位发送到计算节点进行处理，这里的处理是指可以进行任意的处
理，哪怕是过滤数据，在处理时同时可以获取当前分区索引。
val dataRDD1 = dataRDD.mapPartitionsWithIndex(
(index, datas) => {
datas.map(index, _)
} )4、flatMap(f) 扁平化映射
➢ 函数签名
def flatMap[U: ClassTag](f: T => TraversableOnce[U]): RDD[U]
➢ 函数说明
将处理的数据进行扁平化后再进行映射处理，所以算子也称之为扁平映射
val rdd: RDD[String] = sc.makeRDD(List("Hello Scala", "Hello Spark"))
val flatRDD: RDD[String] = rdd.flatMap(s => {s.split(" ")})5、glom() 封装数组
/**
* def glom(): RDD[Array[T]]
➢ 函数说明
将同一个分区的数据直接转换为相同类型的内存数组进行处理，分区不变
将同一分区的数据封装成一个数组
* @param args
*/
def main(args: Array[String]): Unit = {
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
val sc = new SparkContext(sparkConf)
// TODO 算子 - glom
val rdd : RDD[Int] = sc.makeRDD(List(1,2,3,4), 2)
// List => Int
// Int => Array
val glomRDD: RDD[Array[Int]] = rdd.glom()
glomRDD.collect().foreach(data=> println(data.mkString(",")))6、groupBy(f) 分组
/**
* ➢ 函数签名
def groupBy[K](f: T => K)(implicit kt: ClassTag[K]): RDD[(K, Iterable[T])]
➢ 函数说明
将数据根据指定的规则进行分组, 分区默认不变，但是数据会被打乱重新组合，我们将这样
的操作称之为 shuffle。极限情况下，数据可能被分在同一个分区中
一个组的数据在一个分区中，但是并不是说一个分区中只有一个组
*/
val rdd = sc.makeRDD(List("Hello", "Spark", "Scala", "Hadoop"), 2)
// 分组和分区没有必然的关系
//charAt(0)得到第一个字母x=>x.charAt(0)
//以首字母进行分区
val groupRDD = rdd.groupBy(_.charAt(0))
groupRDD.collect().foreach(println)7、filter(f=>Boolean) 过滤
/**
* ➢ 函数签名
def filter(f: T => Boolean): RDD[T]
➢ 函数说明
将数据根据指定的规则进行筛选过滤，符合规则的数据保留，不符合规则的数据丢弃。
当数据进行筛选过滤后，分区不变，但是分区内的数据可能不均衡，生产环境下，可能会出
现数据倾斜
*/
val rdd = sc.makeRDD(List(1,2,3,4))
//对rdd数据进行过滤，保留奇数
val filterRDD: RDD[Int] = rdd.filter(num=>num%2!=0)
filterRDD.collect().foreach(println)8、sample(Boolean,Double,Long) 抽样
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
val sc = new SparkContext(sparkConf)
➢ 函数签名
def sample(
withReplacement: Boolean,
fraction: Double,
seed: Long = Utils.random.nextLong): RDD[T]
➢ 函数说明
根据指定的规则从数据集中抽取数据
// TODO 算子 - sample
val rdd = sc.makeRDD(List(1,2,3,4,5,6,7,8,9,10))
// sample算子需要传递三个参数
// 1. 第一个参数表示，抽取数据后是否将数据返回 true（放回），false（不放回）
// 2. 第二个参数表示，
// 如果抽取不放回的场合：数据源中每条数据被抽取的概率，基准值的概念
// 如果抽取放回的场合：表示数据源中的每条数据被抽取的可能次数
// 3. 第三个参数表示，抽取数据时随机算法的种子
// 如果不传递第三个参数，那么使用的是当前系统时间
// println(rdd.sample(
// false,
// 0.4
// //1
// ).collect().mkString(","))
println(rdd.sample(true,2,1).collect().mkString(","))
sc.stop()9、distinct() 去重
val rdd = sc.makeRDD(List(1,2,3,4,1,2,3,4))/** * ➢ 函数签名 def distinct()(implicit ord: Ordering[T] = null): RDD[T] def distinct(numPartitions: Int)(implicit ord: Ordering[T] = null): RDD[T] ➢ 函数说明 将数据集中重复的数据去重 *///实现原理是先map后用reduceByKey做聚合// map(x => (x, null)).reduceByKey((x, _) => x, numPartitions).map(_._1)// (1, null),(2, null),(3, null),(4, null),(1, null),(2, null),(3, null),(4, null)// (1, null)(1, null)(1, null)// (null, null) => null// (1, null) => 1val rdd1: RDD[Int] = rdd.distinct()rdd1.collect().foreach(println)10、coalesce(Int,Boolean) 减少分区
val rdd = sc.makeRDD(List(1,2,3,4,5,6), 3)/** * ➢ 函数签名def coalesce(numPartitions: Int, shuffle: Boolean = false, partitionCoalescer: Option[PartitionCoalescer] = Option.empty) (implicit ord: Ordering[T] = null) : RDD[T]➢ 函数说明根据数据量缩减分区，用于大数据集过滤后，提高小数据集的执行效率当 spark 程序中，存在过多的小任务的时候，可以通过 coalesce 方法，收缩合并分区，减少分区的个数，减小任务调度成本 */// coalesce方法默认情况下不会将分区的数据打乱重新组合// 这种情况下的缩减分区可能会导致数据不均衡，出现数据倾斜//val newRDD: RDD[Int] = rdd.coalesce(2)// 如果想要让数据均衡，可以进行shuffle处理,第二个参数设为trueval newRDD: RDD[Int] = rdd.coalesce(2,true)11、repartition(Int) 扩大分区
val rdd = sc.makeRDD(List(1,2,3,4,5,6), 2)/** * 函数签名def repartition(numPartitions: Int)(implicit ord: Ordering[T] = null): RDD[T]➢ 函数说明该操作内部其实执行的是 coalesce 操作，参数 shuffle 的默认值为 true。无论是将分区数多的RDD 转换为分区数少的 RDD，还是将分区数少的 RDD 转换为分区数多的 RDD，repartition操作都可以完成，因为无论如何都会经 shuffle 过程。 */// coalesce算子可以扩大分区的，但是如果不进行shuffle操作，是没有意义，不起作用。// 所以如果想要实现扩大分区的效果，需要使用shuffle操作// spark提供了一个简化的操作// 缩减分区：coalesce，如果想要数据均衡，可以采用shuffle//val newRDD: RDD[Int] = rdd.coalesce(3, true)// 扩大分区：repartition, 底层代码调用的就是coalesce，而且肯定采用shuffleval newRDD: RDD[Int] = rdd.repartition(3)12、sortBy(f,Boolean) 排序
val rdd = sc.makeRDD(List(("1", 1), ("11", 2), ("2", 3)), 2)/** * ➢ 函数签名def sortBy[K](f: (T) => K,ascending: Boolean = true,numPartitions: Int = this.partitions.length) (implicit ord: Ordering[K], ctag: ClassTag[K]): RDD[T]➢ 函数说明该操作用于排序数据。在排序之前，可以将数据通过 f 函数进行处理，之后按照 f 函数处理的结果进行排序，默认为升序排列。排序后新产生的 RDD 的分区数与原 RDD 的分区数一致。中间存在 shuffle 的过程sortBy方法可以根据指定的规则对数据源中的数据进行排序，默认为升序，第二个参数可以改变排序的方式sortBy默认情况下，不会改变分区。但是中间存在shuffle操作 */val newRDD = rdd.sortBy(t=>t._1.toInt, false)二、双值类型
1、intersection(rdd) 交集
val rdd1 = sc.makeRDD(List(1,2,3,4))val rdd2 = sc.makeRDD(List(3,4,5,6))val rdd7 = sc.makeRDD(List("3","4","5","6"))/** * ➢ 函数签名 def intersection(other: RDD[T]): RDD[T] ➢ 函数说明 对源 RDD 和参数 RDD 求交集后返回一个新的 RDD */// 交集 : 【3，4】val rdd3: RDD[Int] = rdd1.intersection(rdd2)2、union(rdd) 并集
/** * ➢ 函数签名 def union(other: RDD[T]): RDD[T] ➢ 函数说明 对源 RDD 和参数 RDD 求并集后返回一个新的 RDD */// 并集 : 【1，2，3，4，3，4，5，6】val rdd4: RDD[Int] = rdd1.union(rdd2)println(rdd4.collect().mkString(","))3、subtract(rdd) 差集
/** * ➢ 函数签名 def subtract(other: RDD[T]): RDD[T] ➢ 函数说明 以一个 RDD 元素为主，去除两个 RDD 中重复元素，将其他元素保留下来。求差集 */// 差集 : 【1，2】val rdd5: RDD[Int] = rdd1.subtract(rdd2)println(rdd5.collect().mkString(","))4、zip(rdd) 拉链
/** * ➢ 函数签名 def zip[U: ClassTag](other: RDD[U]): RDD[(T, U)] ➢ 函数说明 将两个 RDD 中的元素，以键值对的形式进行合并。其中，键值对中的 Key 为第 1 个 RDD 中的元素，Value 为第 2 个 RDD 中的相同位置的元素 */// 拉链 : 【1-3，2-4，3-5，4-6】val rdd6: RDD[(Int, Int)] = rdd1.zip(rdd2)val rdd8 = rdd1.zip(rdd7)println(rdd6.collect().mkString(","))三、key-value类型
1、partitionBy(Partitioner) 按指定分区器分区
val rdd = sc.makeRDD(List(1,2,3,4),2)/** * ➢ 函数签名def partitionBy(partitioner: Partitioner): RDD[(K, V)]➢ 函数说明将数据按照指定 Partitioner 重新进行分区。Spark 默认的分区器是 HashPartitioner *///必须要是k,v类型的val mapRDD:RDD[(Int, Int)] = rdd.map((_,1))// RDD => PairRDDFunctions// 隐式转换（二次编译）// partitionBy根据指定的分区规则对数据进行重分区val newRDD = mapRDD.partitionBy(new HashPartitioner(2))newRDD.partitionBy(new HashPartitioner(2))2、reduceByKey(f) 按key对值聚合
/** * ➢ 函数签名def reduceByKey(func: (V, V) => V): RDD[(K, V)]def reduceByKey(func: (V, V) => V, numPartitions: Int): RDD[(K, V)]➢ 函数说明可以将数据按照相同的 Key 对 Value 进行聚合 */// reduceByKey : 相同的key的数据进行value数据的聚合操作// scala语言中一般的聚合操作都是两两聚合，spark基于scala开发的，所以它的聚合也是两两聚合// 【1，2，3】// 【3，3】// 【6】// reduceByKey中如果key的数据只有一个，是不会参与运算的。val reduceRDD: RDD[(String, Int)] = rdd.reduceByKey( (x:Int, y:Int) => { //println(s"x = ${x}, y = ${y}") //指定聚合逻辑 x + y} )3、groupByKey() 按key对value分组
/** * ➢ 函数签名 def groupByKey(): RDD[(K, Iterable[V])] def groupByKey(numPartitions: Int): RDD[(K, Iterable[V])] def groupByKey(partitioner: Partitioner): RDD[(K, Iterable[V])] ➢ 函数说明 将数据源的数据根据 key 对 value 进行分组 */ // groupByKey : 将数据源中的数据，相同key的数据分在一个组中，形成一个对偶元组 // 元组中的第一个元素就是key， // 元组中的第二个元素就是相同key的value的集合 val groupRDD: RDD[(String, Iterable[Int])] = rdd.groupByKey()4、aggregateByKey(初始值)(分区内逻辑,分区间逻辑)
/** * ➢ 函数签名def aggregateByKey[U: ClassTag](zeroValue: U)(seqOp: (U, V) => U, combOp: (U, U) => U): RDD[(K, U)]➢ 函数说明将数据根据不同的规则进行分区内计算和分区间计算 */// aggregateByKey存在函数柯里化，有两个参数列表// 第一个参数列表,需要传递一个参数，表示为初始值// 主要用于当碰见第一个key的时候，和value进行分区内计算// 第二个参数列表需要传递2个参数// 第一个参数表示分区内计算规则// 第二个参数表示分区间计算规则// (a,【1,2】), (a, 【3，4】)// (a, 2), (a, 4)// (a, 6)rdd.aggregateByKey(0)( (x, y) => math.max(x, y),//分区内取最大值 (x, y) => x + y//分区间相加).collect.foreach(println)5、foldByKey(初始值)(逻辑)
/** * ➢ 函数签名def foldByKey(zeroValue: V)(func: (V, V) => V): RDD[(K, V)]➢ 函数说明当分区内计算规则和分区间计算规则相同时，aggregateByKey 就可以简化为 foldByKey *///rdd.aggregateByKey(0)(_+_, _+_).collect.foreach(println)// 如果聚合计算时，分区内和分区间计算规则相同，spark提供了简化的方法rdd.foldByKey(0)(_+_).collect.foreach(println)7、mapValues(f) key保持不变，value进行转换
/** * mapValues:key保持不变，value进行转换 */val resultRDD: RDD[(String, Int)] = newRDD.mapValues { //和/次数得到平均值 case (num, cnt) => { num / cnt }}8、combineByKey(f,分区内逻辑,分区间逻辑)
/** * ➢ 函数签名 def combineByKey[C]( createCombiner: V => C, mergeValue: (C, V) => C, mergeCombiners: (C, C) => C): RDD[(K, C)] ➢ 函数说明 最通用的对 key-value 型 rdd 进行聚集操作的聚集函数（aggregation function）。类似于 aggregate()，combineByKey()允许用户返回值的类型与输入不一致 */ // combineByKey : 方法需要三个参数 // 第一个参数表示：将相同key的第一个数据进行结构的转换，实现操作 // 第二个参数表示：分区内的计算规则 // 第三个参数表示：分区间的计算规则 val newRDD : RDD[(String, (Int, Int))] = rdd.combineByKey( v => (v, 1),//第一个参数，将第一个值变成一个元组 ( t:(Int, Int), v ) => { (t._1 + v, t._2 + 1) }, (t1:(Int, Int), t2:(Int, Int)) => { (t1._1 + t2._1, t1._2 + t2._2) } )9、sortByKey(Boolean) 按key进行排序
➢ 函数签名def sortByKey(ascending: Boolean = true, numPartitions: Int = self.partitions.length) : RDD[(K, V)]➢ 函数说明在一个(K,V)的 RDD 上调用，K 必须实现 Ordered 接口(特质)，返回一个按照 key 进行排序的val dataRDD1 = sparkContext.makeRDD(List(("a",1),("b",2),("c",3)))val sortRDD1: RDD[(String, Int)] = dataRDD1.sortByKey(true)val sortRDD1: RDD[(String, Int)] = dataRDD1.sortByKey(false)10、join(rdd) 连接
val rdd1 = sc.makeRDD(List(("a", 1), ("a", 2), ("c", 3)))val rdd2 = sc.makeRDD(List(("a", 5), ("c", 6),("a", 4)))/** * ➢ 函数签名 def join[W](other: RDD[(K, W)]): RDD[(K, (V, W))] ➢ 函数说明 在类型为(K,V)和(K,W)的 RDD 上调用，返回一个相同 key 对应的所有元素连接在一起的 (K,(V,W))的 RDD */// join : 两个不同数据源的数据，相同的key的value会连接在一起，形成元组// 如果两个数据源中key没有匹配上，那么数据不会出现在结果中// 如果两个数据源中key有多个相同的，会依次匹配，可能会出现笛卡尔乘积，数据量会几何性增长，会导致性能降低。val joinRDD: RDD[(String, (Int, Int))] = rdd1.join(rdd2)11、leftOuterJoin 左外连接
val rdd1 = sc.makeRDD(List(("a", 1), ("b", 2)//, ("c", 3)))
val rdd2 = sc.makeRDD(List(("a", 4), ("b", 5),("c", 6)))
/**
* ➢ 函数签名
def leftOuterJoin[W](other: RDD[(K, W)]): RDD[(K, (V, Option[W]))]
➢ 函数说明
类似于 SQL 语句的左外连接
*/
//val leftJoinRDD = rdd1.leftOuterJoin(rdd2)12、rightOuterJoin 右外连接
/**
* ➢ 函数签名
def rightOuterJoin[W](other: RDD[(K, W)]): RDD[(K, (V, Option[W]))]
➢ 函数说明
类似于 SQL 语句的右外连接
*/
//val leftJoinRDD = rdd1.leftOuterJoin(rdd2)
val rightJoinRDD = rdd1.rightOuterJoin(rdd2)13、cogroup(rdd1,rdd2…)
val rdd1 = sc.makeRDD(List(("a", 1), ("b", 2),("c", 3)))
val rdd2 = sc.makeRDD(List(("a", 4), ("b", 5),("c", 6),("c", 7)))
/**
* ➢ 函数签名
def cogroup[W](other: RDD[(K, W)]): RDD[(K, (Iterable[V], Iterable[W]))]
➢ 函数说明
在类型为(K,V)和(K,W)的 RDD 上调用，返回一个(K,(Iterable<V>,Iterable<W>))类型的 RDD
*/
// cogroup : connect + group (分组，连接)
val cgRDD: RDD[(String, (Iterable[Int], Iterable[Int]))] = rdd1.cogroup(rdd2)
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
