Spark常用转换因子介绍

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()的区别

  1. map():每次处理一条数据。
  2. mapPartitions():每次处理一个分区的数据,这个分区的数据处理完后,原 RDD 中该分区的数据才能释放,可能导致 OOM。
  3. 开发指导:当内存空间较大的时候建议使用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
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

梦里藍天

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值