Spark-RDD 转换算子(Value 类型)
Posted open_test01
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Spark-RDD 转换算子(Value 类型)相关的知识,希望对你有一定的参考价值。
转换算子其实就是RDD中对数据进行封装转换的方法。
RDD 根据数据处理方式的不同将算子整体上分为 Value 类型、双 Value 类型和 Key-Value 类型。
1、map
将处理的数据逐条进行映射转换,这里的转换可以是类型的转换,也可以是值的转换。
def map[U: ClassTag](f: T => U): RDD[U]
def main(args: Array[String]): Unit =
//准备环境
//"*"代表线程的核数 应用程序名称"RDD"
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
val sc = new SparkContext(sparkConf)
val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4,5,6))
//算子map
//转换函数
def mapFun(num:Int): Int = //完成乘2操作
num * 2
//map(传入的参数为函数)
val mpRDD: RDD[Int] = rdd.map(mapFun)
mpRDD.collect().foreach(println) //输出检验
//关闭环境
sc.stop()
但是一般情况方法内参数函数使用致简原则匿名函数作为参数
val mpRDD: RDD[Int] = rdd.map(_*2) //完成乘2操作
map体现RDD的并行计算
def main(args: Array[String]): Unit =
//准备环境
//"*"代表线程的核数 应用程序名称"RDD"
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
val sc = new SparkContext(sparkConf)
val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4,5,6),1)//一个分区
//1、rdd计算一个分区内的数据一个一个执行逻辑
//当一个数据的流程全部执行后才会执行下一条数据 分区内数据的执行是有序的
//2、不同分区的数据分区的计算是无序的
val mpRDD1: RDD[Int] = rdd.map(
num =>
println("num操作1=>"+num)
num
)
val mpRDD2: RDD[Int] = mpRDD1.map(
num =>
println("num操作2=>"+num)
num
)
mpRDD2.collect()
//关闭环境
sc.stop()
当分区为1时
当分区为2时
2、mapPartitions
将待处理的数据以分区为单位发送到计算节点进行处理,这里的处理是指可以进行任意的处 理,哪怕是过滤数据。
def mapPartitions[U: ClassTag](
f: Iterator[T] => Iterator[U],
preservesPartitioning: Boolean = false): RDD[U]
- 可以以分区为单位作为数据转换操作
- 缺点:但是它会把分区的数据加载到内存中进行引用 如果处理完了数据它不会释放内存因为它存在对象的引用。
- 内存较小 数据量较大容易出现内存溢出的情况
def main(args: Array[String]): Unit =
//准备环境
//"*"代表线程的核数 应用程序名称"RDD"
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
val sc = new SparkContext(sparkConf)
val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4,5,6),2)//2个分区
//mapPartitions(迭代器) 一次性处理一个分区的数据处理完成后再处理下一个分区的数据
val mapRDD: RDD[Int] = rdd.mapPartitions(
iter =>
println("------") //输出现几次则有几个分区
iter.map(_ * 2)
)
mapRDD.collect().foreach(println)
//关闭环境
sc.stop()
3、mapPartitionsWithIndex
将待处理的数据以分区为单位发送到计算节点进行处理,这里的处理是指可以进行任意的处 理,哪怕是过滤数据,在处理时同时可以获取当前分区索引。
def mapPartitionsWithIndex[U: ClassTag](
f: (Int, Iterator[T]) => Iterator[U],
preservesPartitioning: Boolean = false): RDD[U]
只保留打印第二个分区的数据
def main(args: Array[String]): Unit =
//准备环境
//"*"代表线程的核数 应用程序名称"RDD"
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
val sc = new SparkContext(sparkConf)
val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4,5,6),2)//2个分区
//需求功能: 只保留打印第二个分区的数据
val mpiRDD: RDD[Int] = rdd.mapPartitionsWithIndex(
(index, iter) =>
if (index == 1) //打印索引为1的分区 即第二个分区
iter
else
Nil.iterator
)
mpiRDD.collect().foreach(println)
//关闭环境
sc.stop()
显示改数据属于哪个分区
def main(args: Array[String]): Unit =
//准备环境
//"*"代表线程的核数 应用程序名称"RDD"
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
val sc = new SparkContext(sparkConf)
val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4,5,6),4)//4个分区
//需求功能:显示改数据属于哪个分区
val mpiRDD = rdd.mapPartitionsWithIndex(
(index, iter) =>
iter.map(
num =>
("分区号"+index+"数据:"+num)
)
)
mpiRDD.collect().foreach(println)
//关闭环境
sc.stop()
4、flatMap
将处理的数据进行扁平化后再进行映射处理,所以算子也称之为扁平映射
def flatMap[U: ClassTag](f: T => TraversableOnce[U]): RDD[U]
def main(args: Array[String]): Unit =
//准备环境
//"*"代表线程的核数 应用程序名称"RDD"
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
val sc = new SparkContext(sparkConf)
val rdd: RDD[List[Int]] = sc.makeRDD(List(List(1,2),List(3,4)))
//把rdd中的List中的List分成个体
val fltRDD: RDD[Int] = rdd.flatMap(
list =>
list
)
fltRDD.collect().foreach(println)
//关闭环境
sc.stop()
5、glom
将同一个分区的数据直接转换为相同类型的内存数组进行处理,分区不变
def glom(): RDD[Array[T]]
def main(args: Array[String]): Unit =
//准备环境
//"*"代表线程的核数 应用程序名称"RDD"
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
val sc = new SparkContext(sparkConf)
val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4),2) //分区:2
//List => Int
//Int => Array
val gRDD: RDD[Array[Int]] = rdd.glom()
gRDD.collect().foreach(i => println(i.mkString(",")))
//关闭环境
sc.stop()
计算所有分区最大值求和(分区内取最大值,分区间最大值求和)
def main(args: Array[String]): Unit =
//准备环境
//"*"代表线程的核数 应用程序名称"RDD"
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
val sc = new SparkContext(sparkConf)
val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4),2) //分区:2
val grdd: RDD[Array[Int]] = rdd.glom()
val maxRDD: RDD[Int] = grdd.map(
arr =>
arr.max
)
println(maxRDD.collect().sum)
//关闭环境
sc.stop()
6、groupBy
将数据根据指定的规则进行分组, 分区默认不变,但是数据会被打乱重新组合,我们将这样 的操作称之为 shuffle。极限情况下,数据可能被分在同一个分区中
一个组的数据在一个分区中,但是并不是说一个分区中只有一个组
def groupBy[K](f: T => K)(implicit kt: ClassTag[K]): RDD[(K, Iterable[T])]
def main(args: Array[String]): Unit =
//准备环境
//"*"代表线程的核数 应用程序名称"RDD"
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
val sc = new SparkContext(sparkConf)
val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4),2) //分区:2
//groupBy会将数据源中每一个数据进行分组判断,根据返回的分组Key进行分组
//相同的Key数据会放置在一个组中
//groupBy(参数为分组条件的函数)
val gpRDD: RDD[(Int, Iterable[Int])] = rdd.groupBy(
num => num % 2
)
gpRDD.collect().foreach(println)
//关闭环境
sc.stop()
7、filter
将数据根据指定的规则进行筛选过滤,符合规则的数据保留,不符合规则的数据丢弃。 当数据进行筛选过滤后,分区不变
但是分区内的数据可能不均衡,生产环境下,可能会出 现数据倾斜。
def filter(f: T => Boolean): RDD[T]
def main(args: Array[String]): Unit =
//准备环境
//"*"代表线程的核数 应用程序名称"RDD"
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
val sc = new SparkContext(sparkConf)
val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4))
//需求:过滤偶数留下奇数
val fRDD: RDD[Int] = rdd.filter(num => num%2 !=0)
fRDD.collect().foreach(println)
//关闭环境
sc.stop()
8、sample
根据指定的规则从数据集中抽取数据
def sample(
withReplacement: Boolean, //抽取完受否放回
fraction: Double, //比例
seed: Long = Utils.random.nextLong): RDD[T] //随机数种子(基准值)
)
def main(args: Array[String]): Unit =
//准备环境
//"*"代表线程的核数 应用程序名称"RDD"
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
val sc = new SparkContext(sparkConf)
val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4,5,6,7,8,9,10))
//sample(抽取后是否放回,每条数据被抽取的概率,随机算法的种子)
//如果传染第3个参数则每次抽取的数据是固定的 不传的话就是使用当前系统时间则是随机的
println(rdd.sample(
false,
0.5,
1
).collect().mkString(","))
//关闭环境
sc.stop()
9、distinct
将数据集中重复的数据去重
def distinct()(implicit ord: Ordering[T] = null): RDD[T]
def distinct(numPartitions: Int)(implicit ord: Ordering[T] = null): RDD[T]
def main(args: Array[String]): Unit =
//准备环境
//"*"代表线程的核数 应用程序名称"RDD"
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
val sc = new SparkContext(sparkConf)
val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4,5,1,2,3,4,5))
//去重
val dRDD = rdd.distinct()
dRDD.collect().foreach(println)
//关闭环境
sc.stop()
10、coalesce
根据数据量缩减分区,用于大数据集过滤后,提高小数据集的执行效率 当 spark 程序中,存在过多的小任务的时候,可以通过 coalesce 方法,收缩合并分区,减少 分区的个数,减小任务调度成本
def coalesce(numPartitions: Int, shuffle: Boolean = false,
partitionCoalescer: Option[PartitionCoalescer] = Option.empty)
(implicit ord: Ordering[T] = null)
: RDD[T]
def main(args: Array[String]): Unit =
//准备环境
//"*"代表线程的核数 应用程序名称"RDD"
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
val sc = new SparkContext(sparkConf)
val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4),4) //4个分区
//缩减分区可能会导致数据倾斜
//需要使数据均衡则要使用shuffle处理
//coalesce(参数为分区数量,是否进行shuffle处理)
val newRDD: RDD[Int] = rdd.coalesce(2,true) //合并为2个分区
newRDD.saveAsTextFile("output")
//关闭环境
sc.stop()
11、repartition
该操作内部其实执行的是 coalesce 操作,参数 shuffle 的默认值为 true。无论是将分区数多的 RDD 转换为分区数少的 RDD,还是将分区数少的 RDD 转换为分区数多的 RDD,repartition 操作都可以完成,因为无论如何都会经 shuffle 过程。
def repartition(numPartitions: Int)(implicit ord: Ordering[T] = null): RDD[T]
def main(args: Array[String]): Unit =
//准备环境
//"*"代表线程的核数 应用程序名称"RDD"
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
val sc = new SparkContext(sparkConf)
val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4),2) //2个分区
//repartition底层就是调用的coalesce 且增加了shuffle条件
val newRDD: RDD[Int] = rdd.repartition(4) //扩大为4个分区
newRDD.saveAsTextFile("output")
//关闭环境
sc.stop()
12、sortBy
该操作用于排序数据。在排序之前,可以将数据通过 f 函数进行处理,之后按照 f 函数处理 的结果进行排序,默认为升序排列。排序后新产生的 RDD 的分区数与原 RDD 的分区数一 致。中间存在 shuffle 的过程
def sortBy[K](
f: (T) => K,
ascending: Boolean = true,
numPartitions: Int = this.partitions.length)
(implicit ord: Ordering[K], ctag: ClassTag[K]): RDD[T]
def main(args: Array[String]): Unit =
//准备环境
//"*"代表线程的核数 应用程序名称"RDD"
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
val sc = new SparkContext(sparkConf)
val rdd: RDD[Int] = sc.makeRDD(List(2,1,6,5,9,4,8,7),2) //2个分区
//sortBy(排序规则)
val SRDD: RDD[Int] = rdd.sortBy(n=>n)
//存在 shuffle 的过程
SRDD.saveAsTextFile("output")
//关闭环境
sc.stop()
以上是关于Spark-RDD 转换算子(Value 类型)的主要内容,如果未能解决你的问题,请参考以下文章