Spark常用转换因子介绍

梦里藍天

已于 2022-03-30 08:09:24 修改

阅读量1.4k

点赞数

分类专栏： Spark 大数据文章标签： spark

于 2020-09-20 07:33:56 首次发布

How to hatch an egg without an incubator

本文链接：https://blog.csdn.net/ren365880/article/details/108664805

版权

Spark 大数据专栏收录该内容

7 篇文章 0 订阅

订阅专栏

Map(f):

作用：使RDD数据集合中的每一个数据与另一个数据组合，返回最终组合后的新的RDD；

var res = Array(10,30,40,60,80,90,56,5,9);
var rdd = res.map((_,1)).collect();
结果：(10,1)(30,1)(40,1)(60,1)(80,1)(90,1)(56,1)(5,1)(9,1)

MapPartitions(f: Iterator[Int] => Iterator[U],preservesPartitioning: Boolean = false)

作用：通过对RDD的每个分区应用一个函数来返回一个新的RDD。preservesPartitioning ‘表示输入函数是否传入了分区器，默认是’ false '。

var res = sc.parallelize(1 to 10);
var rdd = res.mapPartitions(i => i.map((_,2))).collect();
结果：(1,2)(2,2)(3,2)(4,2)(5,2)(6,2)(7,2)(8,2)(9,2)(10,2)

mapPartitionsWithIndex[U: ClassTag]( f: (Int, Iterator[T]) => Iterator[U],preservesPartitioning: Boolean = false)

作用：通过对RDD的每个分区应用一个函数，返回一个新的RDD，同时跟踪原始分区的索引。preservesPartitioning ‘表示输入函数是否传入了分区器，默认是’ false '。

var res = sc.parallelize(1 to 10,2);//2个分区
var rdd = res.mapPartitionsWithIndex((index,i) => i.map((_,index))).collect();
结果：(1,0)(2,0)(3,0)(4,0)(5,0)(6,1)(7,1)(8,1)(9,1)(10,1)

map()和mapPartitions()的区别

map()：每次处理一条数据。
mapPartitions()：每次处理一个分区的数据，这个分区的数据处理完后，原 RDD 中该分区的数据才能释放，可能导致 OOM。
开发指导：当内存空间较大的时候建议使用mapPartitions()，以提高处理效率。

flatMap[U: ClassTag](f: T => TraversableOnce[U]): RDD[U]

作用：首先对RDD的所有元素应用一个函数，然后将结果扁平化，最后返回一个新的RDD。

val res = sc.parallelize(Array(Array(1,2,3,4,5,7,8,9,10),Array(1,2,3,4,5,7,8,9,10)));
res.foreach(println);
var rdd = res.flatMap(x => x.flatMap(y => Array(y))).collect();
//4.循环打印
rdd.foreach(println);
结果：[I@f49b5e8  [I@5c746cd //第一个println
1 2 3 4 5 7 8 9 10 1 2 3 4 5 7 8 9 10 //第二个println

glom(): RDD[Array[T]]

作用：分别将集合中每个分区中的元素合并到一个数组中创建的，返回一个RDD，有几个分区返回的RDD就有几个数组。

 val res = sc.parallelize(Array(1,2,3,4,5,7,8,9,10),4);//分了4个分区
 var rdd = res.glom().collect();
 var rdd1 = rdd.map(_.toList);
 //4.循环打印
 rdd1.foreach(println);
 结果：List(1, 2) List(3, 4) List(5, 7) List(8, 9, 10)

groupBy[K](f: T => K)(implicit kt: ClassTag[K]): RDD[(K, Iterable[T])]

作用：每个组由一个键和映射到该键的元素序列组成。每个组内的元素的顺序是没有保证的，甚至可能在每次评估RDD的结果时有所不同。这个操作可能非常昂贵。如果要对每个键进行分组以执行聚合(比如求和或平均)，请使用’PairRDDFunctions。aggregateByKey或PairRDDFunctions。reduceByKey’将提供更好的性能。

val res = sc.parallelize(Array(1,2,3,4,5,6,7,8,9,10));
//res.foreach(println);
var rdd = res.groupBy(x => if(x % 2 == 0) "o" else "j").collect();
//var rdd1 = rdd.map(_.toList);
//4.循环打印
rdd.foreach(println);
结果：(j,CompactBuffer(1, 3, 5, 7, 9))  (o,CompactBuffer(2, 4, 6, 8, 10))

filter(f: T => Boolean): RDD[T]

作用：返回一个只包含满足条件的元素新的RDD，

val res = sc.parallelize(Array(1,2,3,4,5,6,7,8,9,10));
var rdd = res.filter(_ % 2 == 0).collect();
//4.循环打印
rdd.foreach(println);
结果：2 4 6 8 10

sample(withReplacement: Boolean, fraction: Double, seed: Long = Utils.random.nextLong): RDD[T]

作用：1. 以指定的随机种子随机抽样出比例为fraction的数据，(抽取到的数量是: size * fraction). 需要注意的是得到的结果并不能保证准确的比例.
2. withReplacement表示是抽出的数据是否放回，true为有放回的抽样，false为无放回的抽样. 放回表示数据有可能会被重复抽取到, false 则不可能重复抽取到. 如果是false, 则fraction必须是:[0,1], 是 true 则大于等于0就可以了.
3. seed用于指定随机数生成器种子。一般用默认的, 或者传入当前的时间戳

// 3. 使用sc创建RDD并执行操作
val res = sc.parallelize(Array(1,2,3,4,5,6,7,8,9,10));
var rdd = res.sample(false,0.3).collect();
//4.循环打印
rdd.foreach(println);
结果：1 7 8 9

distinct(): RDD[T]

作用：对 RDD 中元素执行去重操作. 参数表示任务的数量.默认值和分区数保持一致.

val res = sc.parallelize(Array(1,1,3,3,5,5,7,7,9,9));
var rdd = res.distinct().collect();
//4.循环打印
rdd.foreach(println);
结果：1 9 5 3 7

coalesce(numPartitions: Int, shuffle: Boolean = false, partitionCoalescer: Option[PartitionCoalescer] = Option.empty) (implicit ord: Ordering[T] = null) : RDD[T]

作用：返回一个新的RDD，该RDD被简化为“指定数量”的分区。
如果从1000个分区到100个分区，就不会发生洗牌，如果100分区分到1000分区则需要洗牌。如果请求的分区数量较大，请将保持当前分区数量。
如果你正在做一个极限的合并操作，例如numPartitions = 1，这可能会导致你的计算发生在比你想要的更少的节点上(例如，一个节点在numPartitions = 1的情况下)。为了避免这种情况，你可以传递shuffle = true。这将添加一个转移步骤，但意味着当前上游分区将并行执行(无论当前分区是什么)。
使用shuffle = true，可以合并到更大数量的分区。如果您只有少量的分区(比如100个)，而其中一些分区可能异常大，那么这将非常有用。调用coalesce(1000, shuffle = true)将产生1000个分区，使用散列分区器分发数据。传入的可选分区合并器必须是可序列化的

val res = sc.parallelize(Array(1,2,3,4,5,6,7,8,9,10),5);
println("现有分区："+res.getNumPartitions);
var rdd = res.coalesce(2);
println("coalesce后现有分区："+rdd.getNumPartitions);
结果：现有分区：5 coalesce后现有分区：2

sortBy[K]( f: (T) => K, ascending: Boolean = true, numPartitions: Int = this.partitions.length) (implicit ord: Ordering[K], ctag: ClassTag[K]): RDD[T]

作用：返回按给定键函数排序的RDD，默认升序，分区数量与原始分区数量一至。

 val res = sc.parallelize(Array(1,2,3,4,5,6,7,8,9,10));
 var rdd = res.sortBy(-_).collect();//+_升序排列
//4.循环打印
rdd.foreach(println);
结果：10 9 8 7 6 5 4 3 2 1