RDD的转化之value和双value类型

最新推荐文章于 2023-03-10 18:14:21 发布

James的小迷弟

最新推荐文章于 2023-03-10 18:14:21 发布

阅读量208

点赞数

分类专栏：笔记文章标签： spark

本文链接：https://blog.csdn.net/qq_45760556/article/details/108862137

版权

笔记专栏收录该内容

3 篇文章 0 订阅

订阅专栏

一、map(func)与flatmap（func）的区别

map()是将函数用于RDD中的每个元素，将返回值构成新的RDD。

flatmap()是将函数应用于RDD中的每个元素，将返回的迭代器的所有内容构成新的RDD。

举一个简单的例子：输入一个 1 到 5 的集合，让他们返回每个值1 to 5的值

map（）

 	val sc: SparkContext = new SparkContext(conf)
    val ListRDD: RDD[Int] = sc.parallelize(1 to 5)
    val MapRDD: RDD[Range.Inclusive] = ListRDD.map(1 to _)
    MapRDD.collect().foreach(print)
    
    
    #######输出结果
    Range(1)Range(1, 2)Range(1, 2, 3)Range(1, 2, 3, 4)Range(1, 2, 3, 4, 5)

flatmap（func）

 val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("WordCount")

    val sc: SparkContext = new SparkContext(conf)
    val ListRDD: RDD[Int] = sc.parallelize(1 to 5)
    
   	val FlatMap: RDD[Int] = ListRDD.flatMap(1 to _)
    val MapRDD: RDD[String] = FlatMap.map(_ + "  ")
    MapRDD.collect().foreach(print)
    
    
    
    ######输出结果
    1  1  2  1  2  3  1  2  3  4  1  2  3  4  5

map函数会对每一条输入进行指定的操作，然后为每一条输入返回一个对象；而flatMap函数则是两个操作的集合——正是“先映射后扁平化”：

操作1：同map函数一样：对每一条输入进行指定的操作，然后为每一条输入返回一个对象

操作2：最后将所有对象合并为一个对象

二、glom（）

1. 作用：

将每一个分区形成一个数组，形成新的RDD类型时RDD[Array[T]]

2.实现

val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("WordCount")

    val sc: SparkContext = new SparkContext(conf)

    val listRDD: RDD[Int] = sc.parallelize(1 to 16, 4)
    val golmRDD: RDD[Array[Int]] = listRDD.glom()
    golmRDD.collect().foreach(array=>{
     println( array.mkString(","))

    })
    
    
    
##########结果
1,2,3,4
5,6,7,8
9,10,11,12
13,14,15,16

三、groupBy（）

1.作用：

分组，按照传入函数的返回值进行分组。将相同的key对应的值放入一个迭代器。

2.实现：

 val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("WordCount")

    val sc: SparkContext = new SparkContext(conf)

    val listRDD: RDD[Int] = sc.parallelize(1 to 16)
    val grouopRDD: RDD[(Int, Iterable[Int])] = listRDD.groupBy(_ % 2)

    grouopRDD.collect().foreach(println)
    
    
    
    ########结果
    (0,CompactBuffer(2, 4, 6, 8, 10, 12, 14, 16))
	(1,CompactBuffer(1, 3, 5, 7, 9, 11, 13, 15))

四、 filter(func)

作用：

过滤。返回一个新的RDD，该RDD由经过func函数计算后返回值为true的输入元素组成。

2.实现：

    val conf = new SparkConf().setMaster("local[*]").setAppName("Word")

    val sc = new SparkContext(conf)

    val listRDD = sc.parallelize(1 to 10)
    
    val filterRDD = listRDD.filter(_%2==0)

    filterRDD.collect().foreach(println)
    
    
#####结果
2
4
6
8
10

五、sample(withReplacement, fraction, seed)

1.作用：

以指定的随机种子随机抽样出数量为fraction的数据，withReplacement表示是抽出的数据是否放回，true为有放回的抽样，false为无放回的抽样，seed用于指定随机数生成器种子。

2.实现

 val conf = new SparkConf().setMaster("local[*]").setAppName("Word")

    val sc = new SparkContext(conf)
    val listRDD = sc.parallelize(1 to 10)


    /**
     * 1、withReplacement：元素可以多次抽样(在抽样时替换)
     *
     * 2、fraction：期望样本的大小作为RDD大小的一部分，
     * 当withReplacement=false时：选择每个元素的概率;分数一定是[0,1] ；
     * 当withReplacement=true时：选择每个元素的期望次数; 分数必须大于等于0。
     *
     * 3、seed：随机数生成器的种子

     * seed会对RDD中的所有内容进行打分,当分数大于fraction时，就会输出出来
     */
    val sampleRDD = listRDD.sample(true, 0.6, 2)

    sampleRDD.collect().foreach(println)
    
    
    #########结果
    1
	2
	5
	6
	6
	10
	10

六、distinct（）

1.作用：

对源RDD进行去重后返回一个新的RDD。默认情况下，只有8个并行任务来操作，但是可以传入一个可选的numTasks参数改变它。

2.实现：

 val conf = new SparkConf().setMaster("local[*]").setAppName("Word")

    val sc = new SparkContext(conf)

    val listRDD = sc.parallelize(List(1, 2, 3, 1, 1, 3, 4, 5, 6, 2, 2, 1))

    val distinctRDD = listRDD.distinct()

    distinctRDD.collect().foreach(println)
    
    
 #######结果
1
2
3
4
5
6

七、 coalesce(numPartitions)

1.作用：

缩减分区数，用于大数据集过滤后，提高小数据集的执行效率。

2.实现：

val conf = new SparkConf().setMaster("local[*]").setAppName("Word")
    
    val sc = new SparkContext(conf)
    val listRDD = sc.parallelize(1 to 15, 4)

    val coalesceRDD = listRDD.coalesce(2)

    coalesceRDD.saveAsTextFile("output")

八、repartition(numPartitions)

1.作用

根据分区数，重新通过网络随机洗牌所有数据。

2.实现

val conf = new SparkConf().setMaster("local[*]").setAppName("Word")

    val sc = new SparkContext(conf)
    val listRDD = sc.parallelize(1 to 16, 4)

    val coalesceRDD = listRDD.repartition(2)

    coalesceRDD.saveAsTextFile("output")

coalesce和repartition的区别

将rdd中一个分区的数据打乱重组到其他不同的分区的操作，称之为shuffle操作

\1. coalesce重新分区，可以选择是否进行shuffle过程。由参数shuffle: Boolean = false/true决定。

\2. repartition实际上是调用的coalesce，默认是进行shuffle的

九、sortBy(func,[ascending], [numTasks])

1.作用

使用func先对数据进行处理，按照处理后的数据比较结果排序，默认为正序。

2.实现

    val conf = new SparkConf().setMaster("local[*]").setAppName("Word")

    val sc = new SparkContext(conf)

    val listRDD = sc.parallelize(1 to 10)

    val sortByRDD = listRDD.sortBy(_ % 3)

    sortByRDD.collect().foreach(println)

十、union(otherDataset)

1.作用：

对源RDD和参数RDD求并集后返回一个新的RDD。（将两个RDD进行合并）

2.实现：

val conf = new SparkConf().setMaster("local[*]").setAppName("Word")

    val sc = new SparkContext(conf)

    val listRDD1 = sc.parallelize(1 to 4)
    val listRDD2 = sc.parallelize(5 to 10)

    val unionRDD: RDD[Int] = listRDD1.union(listRDD2)

    val mapRDD = unionRDD.map(_ + "   ")

    mapRDD.collect().foreach(print)


###结果
1   2   3   4   5   6   7   8   9   10

十一、 subtract (otherDataset)

1.作用：

计算差的一种函数，去除两个RDD中相同的元素，不同的RDD将保留下来

2.实现

    val conf = new SparkConf().setMaster("local[*]").setAppName("Word")

    val sc = new SparkContext(conf)

    val listRDD1 = sc.parallelize(1 to 8)
    val listRDD2 = sc.parallelize(3 to 10)
    

    val subtractRDD: RDD[Int] = listRDD1.subtract(listRDD2)

    subtractRDD.collect().foreach(println)

十二、 intersection(otherDataset)

1.作用：

对源RDD和参数RDD求交集后返回一个新的RDD

2.实现

 val conf = new SparkConf().setMaster("local[*]").setAppName("Word")

    val sc = new SparkContext(conf)

    val listRDD1 = sc.parallelize(1 to 8)
    val listRDD2 = sc.parallelize(3 to 10)


    val intersection: RDD[Int] = listRDD1.intersection(listRDD2)

    intersection.collect().foreach(println)

十三、 cartesian(otherDataset)

1.作用

笛卡尔积（尽量避免使用）

2.实现

val conf = new SparkConf().setMaster("local[*]").setAppName("Word")
    val sc = new SparkContext(conf)
    val listRDD1 = sc.parallelize(Array("a","b","c"))
    val listRDD2 = sc.parallelize(Array("c","d"))

    val cartesianRDD: RDD[(String, String)] = listRDD1.cartesian(listRDD2)

    cartesianRDD.collect().foreach(println)

十四、 zip(otherDataset)

1.作用：

将两个RDD组合成Key/Value形式的RDD,这里默认两个RDD的partition数量以及元素数量都相同，否则会抛出异常。

2.实现

    val conf = new SparkConf().setMaster("local[*]").setAppName("Word")
    val sc = new SparkContext(conf)
    val listRDD1 = sc.parallelize(Array("a","b","c"),3)
    val listRDD2 = sc.parallelize(List(1,2,3),3)

    val zipRDD: RDD[(Int, String)] = listRDD2.zip(listRDD1)
    zipRDD.collect().foreach(println)

James的小迷弟

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
RDD的转化之value和双value类型

一、map(func)与flatmap（func）的区别map()是将函数用于RDD中的每个元素，将返回值构成新的RDD。flatmap()是将函数应用于RDD中的每个元素，将返回的迭代器的所有内容构成新的RDD。举一个简单的例子：输入一个 1 到 5 的集合，让他们返回每个值1 to 5的值map（） val sc: SparkContext = new SparkContext(conf) val ListRDD: RDD[Int] = sc.parallelize(1 to 5)
复制链接

扫一扫