Spark函数详解系列之RDD基本转换

最新推荐文章于 2023-06-26 16:10:48 发布
最新推荐文章于 2023-06-26 16:10:48 发布
阅读量339 收藏
点赞数
分类专栏： Spark

摘要：

RDD：弹性分布式数据集，是一种特殊集合‚ 支持多种来源‚ 有容错机制‚ 可以被缓存‚ 支持并行操作，一个RDD代表一个分区里的数据集

RDD有两种操作算子：

Transformation（转换）：Transformation属于延迟计算，当一个RDD转换成另一个RDD时并没有立即进行转换，仅仅是记住了数据集的逻辑操作

Ation（执行）：触发Spark作业的运行，真正触发转换算子的计算

本系列主要讲解Spark中常用的函数操作：

1.RDD基本转换

2.键-值RDD转换

3.Action操作篇

1.map(func)：数据集中的每个元素经过用户自定义的函数转换形成一个新的RDD，新的RDD叫MappedRDD

（例1）

1

2

3

4

5

6

7

8

9

10

object Map {

def main(args: Array[String]) {

val conf =newSparkConf().setMaster("local").setAppName("map")

val sc =newSparkContext(conf)

val rdd = sc.parallelize(1to10)//创建RDD

val map = rdd.map(_*2)//对RDD中的每个元素都乘于2

map.foreach(x => print(x+" "))

sc.stop()

}

}

输出：

2 4 6 8 10 12 14 16 18 20

(RDD依赖图：红色块表示一个RDD区，黑色块表示该分区集合，下同)

2.flatMap(func):与map类似，但每个元素输入项都可以被映射到0个或多个的输出项，最终将结果”扁平化“后输出

（例2）

1

2

3

4

//...省略sc

val rdd = sc.parallelize(1to5)

val fm = rdd.flatMap(x => (1to x)).collect()

fm.foreach( x => print(x +" "))

输出：

1 1 2 1 2 3 1 2 3 4 1 2 3 4 5

如果是map函数其输出如下：

Range(1) Range(1, 2) Range(1, 2, 3) Range(1, 2, 3, 4) Range(1, 2, 3, 4, 5)

(RDD依赖图)

3.mapPartitions(func):类似与map，map作用于每个分区的每个元素，但mapPartitions作用于每个分区工

func的类型：Iterator[T] => Iterator[U]

假设有N个元素，有M个分区，那么map的函数的将被调用N次,而mapPartitions被调用M次,当在映射的过程中不断的创建对象时就可以使用mapPartitions比map的效率要高很多，比如当向数据库写入数据时，如果使用map就需要为每个元素创建connection对象，但使用mapPartitions的话就需要为每个分区创建connetcion对象

(例3)：输出有女性的名字：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

object MapPartitions {

//定义函数

def partitionsFun(/*index : Int,*/iter : Iterator[(String,String)]) : Iterator[String] = {

var woman = List[String]()

while(iter.hasNext){

val next = iter.next()

next match {

case(_,"female") => woman =/*"["+index+"]"+*/next._1 :: woman

case_ =>

}

}

returnwoman.iterator

}

def main(args: Array[String]) {

val conf =newSparkConf().setMaster("local").setAppName("mappartitions")

val sc =newSparkContext(conf)

val l = List(("kpop","female"),("zorro","male"),("mobin","male"),("lucy","female"))

val rdd = sc.parallelize(l,2)

val mp = rdd.mapPartitions(partitionsFun)

/*val mp = rdd.mapPartitionsWithIndex(partitionsFun)*/

mp.collect.foreach(x => (print(x +" ")))//将分区中的元素转换成Aarray再输出

}

}

输出：

kpop lucy

其实这个效果可以用一条语句完成

1

val mp = rdd.mapPartitions(x => x.filter(_._2 =="female")).map(x => x._1)　

之所以不那么做是为了演示函数的定义

(RDD依赖图)

4.mapPartitionsWithIndex(func):与mapPartitions类似，不同的时函数多了个分区索引的参数

func类型：(Int, Iterator[T]) => Iterator[U]

（例4）：将例3橙色的注释部分去掉即是

输出：（带了分区索引）

[0]kpop [1]lucy

5.union(ortherDataset):将两个RDD中的数据集进行合并，最终返回两个RDD的并集，若RDD中存在相同的元素也不会去重

1

2

3

4

5

6

//省略sc

val rdd1 = sc.parallelize(1to3)

val rdd2 = sc.parallelize(3to5)

val unionRDD = rdd1.union(rdd2)

unionRDD.collect.foreach(x => print(x +" "))

sc.stop　

输出：

1 2 3 3 4 5

　　

6.intersection(otherDataset):返回两个RDD的交集

1

2

3

4

5

6

//省略sc

val rdd1 = sc.parallelize(1to3)

val rdd2 = sc.parallelize(3to5)

val unionRDD = rdd1.intersection(rdd2)

unionRDD.collect.foreach(x => print(x +" "))

sc.stop　

输出：

3 4

7.distinct([numTasks]):对RDD中的元素进行去重

1

2

3

4

5

//省略sc

val list = List(1,1,2,5,2,9,6,1)

val distinctRDD = sc.parallelize(list)

val unionRDD = distinctRDD.distinct()

unionRDD.collect.foreach(x => print(x +" "))　　

输出：

1 6 9 5 2

8.cartesian(otherDataset):对两个RDD中的所有元素进行笛卡尔积操作

1

2

3

4

5

//省略

val rdd1 = sc.parallelize(1to3)

val rdd2 = sc.parallelize(2to5)

val cartesianRDD = rdd1.cartesian(rdd2)

cartesianRDD.foreach(x => println(x +" "))　

输出：

复制代码

(1,2) (1,3) (1,4) (1,5) (2,2) (2,3) (2,4) (2,5) (3,2) (3,3) (3,4) (3,5)

复制代码

(RDD依赖图)

9.coalesce(numPartitions，shuffle):对RDD的分区进行重新分区，shuffle默认值为false,当shuffle=false时，不能增加分区数

目,但不会报错，只是分区个数还是原来的

(例9:）shuffle=false

1

2

3

4

//省略

val rdd = sc.parallelize(1to16,4)

val coalesceRDD = rdd.coalesce(3)//当suffle的值为false时，不能增加分区数(即分区数不能从5->7)

println("重新分区后的分区个数:"+coalesceRDD.partitions.size)　

输出：

重新分区后的分区个数:3
//分区后的数据集
List(1, 2, 3, 4) List(5, 6, 7, 8) List(9, 10, 11, 12, 13, 14, 15, 16)

(例9.1:）shuffle=true

1

2

3

4

5

//...省略

val rdd = sc.parallelize(1to16,4)

val coalesceRDD = rdd.coalesce(7,true)

println("重新分区后的分区个数:"+coalesceRDD.partitions.size)

println("RDD依赖关系:"+coalesceRDD.toDebugString)　　

输出：

复制代码

重新分区后的分区个数:5 RDD依赖关系:(5) MapPartitionsRDD[4] at coalesce at Coalesce.scala:14 [] | CoalescedRDD[3] at coalesce at Coalesce.scala:14 [] | ShuffledRDD[2] at coalesce at Coalesce.scala:14 [] +-(4) MapPartitionsRDD[1] at coalesce at Coalesce.scala:14 [] | ParallelCollectionRDD[0] at parallelize at Coalesce.scala:13 [] //分区后的数据集
List(10, 13) List(1, 5, 11, 14) List(2, 6, 12, 15) List(3, 7, 16) List(4, 8, 9)

复制代码

(RDD依赖图:coalesce(3,flase))

(RDD依赖图:coalesce(3,true))

10.repartition(numPartition):是函数coalesce(numPartition,true)的实现，效果和例9.1的coalesce(numPartition,true)的一样

11.glom():将RDD的每个分区中的类型为T的元素转换换数组Array[T]

1

2

3

4

5

//省略

val rdd = sc.parallelize(1to16,4)

val glomRDD = rdd.glom()//RDD[Array[T]]

glomRDD.foreach(rdd => println(rdd.getClass.getSimpleName))

sc.stop　

输出：

int[] //说明RDD中的元素被转换成数组Array[Int]

12.randomSplit(weight:Array[Double],seed):根据weight权重值将一个RDD划分成多个RDD,权重越高划分得到的元素较多的几率就越大

1

2

3

4

5

6

7

//省略sc

val rdd = sc.parallelize(1to10)

val randomSplitRDD = rdd.randomSplit(Array(1.0,2.0,7.0))

randomSplitRDD(0).foreach(x => print(x +" "))

randomSplitRDD(1).foreach(x => print(x +" "))

randomSplitRDD(2).foreach(x => print(x +" "))

sc.stop　

输出：

2 4
3 8 9

1 5 6 7 10
spark RDD操作详解
09-25
### Spark RDD操作详解 #### 一、RDD概念与特性 **RDD（弹性分布式数据集）**是Apache Spark的核心抽象，代表一种不可变的、可分区的、能够进行并行操作的数据集合。它提供了丰富的API来支持高效的大规模数据处理...
Spark入门RDD操作
NON blog
08-27 565
RDD(Resilient Distributed Datasets),弹性分布式数据集，RDD的简单操作
spark RDD汇总(一)
没有合适的昵称
12-21 2452
collect val listRDD = sc.parallelize[Int](Seq(1, 2, 4, 3, 3, 6), 2) listRDD.collect() // 收集rdd的所有数据 take listRDD.take(2) // 取前两 top listRDD.top(2) // 取最大的两个 first listRDD.first() // 取第一个 ...
Spark系列之(一)——SparkRDD
weixin_43676010的博客
06-26 489
SparkCore RDD的初学习
RDD转换(Transformation)操作
TSY_1222的博客
07-12 1475
1、filter(func) （filter—翻译—>过滤） 筛选出满足函数func的元素，并返回一个新的数据集。 在第3行中，filter()的输入参数line => line.contains("Spark")是一个匿名函数，或者被称为“λ表达式”。 filter(line => line.contains("Spark"))的含义：依次取出lines这个RD...
pandas和spark dataframe互相转换实例详解
09-17
在这个分布式转换函数 `topas()` 中，`repartition()` 方法用于重新分区数据，`mapPartitions()` 函数则将每个分区的数据转换为 `pandas DataFrame`，最后 `collect()` 将所有分区的结果合并成一个列表，再通过 `pd....
Spark RDD 资料
01-31
### Spark RDD 资料详解 #### 一、RDD 的概述 ##### 1.1 什么是 RDD？ **RDD (Resilient Distributed Dataset)**，即弹性分布式数据集，是 Apache Spark 框架中最核心的数据结构之一。它代表了一个不可变、可分区...
spark实验5 rdd编程2.doc
01-10
通过本次实验，不仅熟悉了Spark中RDD的基本操作，包括`map`、`filter`、`reduceByKey`等，还掌握了如何利用这些操作来解决实际问题。此外，还学习了如何使用累加器来统计特定信息。整个实验过程加深了对Spark编程的...
Spark学习复习（5.核心编程）
爱敲代码的小黑的博客
04-14 1532
文章目录Spark核心编程1. RDDRDD与IO一、IO二、RDD什么是 RDD？RDD核心属性一、分区列表二、分区计算函数三、RDD 之间的依赖关系四、分区器（可选）五、首选位置（可选）RDD执行原理一、启动 Yarn 集群环境二、Spark 通过申请资源创建调度节点和计算节点三、Spark 框架根据需求将计算逻辑根据分区划分成不同的任务四、调度节点将任务根据计算节点状态发送到对应的计算节点进行计算RDD基础编程一、从集合（内存）中创建 RDD二、从外部存储（文件）创建RDD三、从其他 RDD 创建四、
RDD内部转换详解
sinat_32329183的博客
06-29 1425
转自scalahome的博客 1，RDD的转换共分为Transformation和Action两类 Transformation和Action的区别在于：Action会触发作业的提交，而Transformation不会触发作业的提交 如map()和collect() [java] view plain copy de
Spark——RDD操作详解
俺叫赵小邪的博客
11-22 9425
一、基本RDD 1、针对各个元素的转化操作 最常用的转化操作是map()和filter()。转化操作map()J接收一个函数，把这个函数用于RDD中的每一个元素，将函数的返回结果作为结果RDD中对应元素。而转化操作filter()则接收一个函数，将RDD满足该函数的元素放入新的RDD中返回。map()的返回值类型不需要和输入类型一样。 从一个RDD变成另外一个RDD。lazy，懒执行 。比如根
Spark入门（四）：RDD基本操作
源码有毒的专栏
08-14 2678
1.RDD转换RDD的所有转换操作都不会进行真正的计算1.1单个RDD转换操作# 创建测试RDD val rdd = sc.parallelize(Array("hello world","java","scala easy"))# 1.map():遍历RDD中的每个元素，将返回值构成新的RDD，返回值类型可和原RDD不一致 val mapRdd = rdd.map(x => "map:"+x) m
一起学Spark(5) -- 基本rdd 常见的转换和行动操作
ouprince
01-26 1685
1.转换操作 1.1 一般的元素操作 #map 和 flatmap #map接受一个函数，把这个函数用于每个rdd中的元素 nums = sc.parallelize([1,2,3,4]) squared = nums.map(lambda x:x*x) #[1,4,9,16] #flatmap也是接受一个函数，把这个函数用于每个rdd中的元素 并扁平化 lines = sc....
spark将Rdd转成list和set
学习进步
08-21 1万+
有需求要将Rdd转成list，上网查资料实现都很复杂，后来发现其实是非常简单的，collect()完已经就是Array了，看源码 /** * Return an array that contains all of the elements in this RDD. * * @note This method should only be used if the resu...
Spark笔记：RDD基本操作（上）
weixin_34037173的博客
05-18 728
　　本文主要是讲解spark里RDD的基础操作。RDD是spark特有的数据模型，谈到RDD就会提到什么弹性分布式数据集，什么有向无环图，本文暂时不去展开这些高深概念，在阅读本文时候，大家可以就把RDD当作一个数组，这样的理解对我们学习RDD的API是非常有帮助的。本文所有示例代码都是使用scala语言编写的。 　　Spark里的计算都是操作RDD进行，那么学习RDD的第一个问题就是如何构建RD...
Spark期末考试练习题
热门推荐
qq_56437391的博客
06-15 2万+
一、单选题 1. 下面的端口不是 Spark 自带的服务端口的是___________。 A. 8080 B. 4040C. 8090D. 18080 2. 下面的描述不是 RDD 的特点的是___________。 A. 可分区 B. 可序列化C. 可修改D. 可持久化 3. 关于广播变量的描述错误的是___________。 A. 任何函数调用 B. 是只读的 C. 存储在各个节点 D. 存储在磁盘或 HDFS 4. 在启动 pyspark 交互式界面时，采用默认的不指定参数的...
如何在Spark中使用动态数据转置
Tybyqi的博客
12-18 833
Dynamic Transpose是Spark中的一个关键转换，因为它需要大量的迭代。本文将为您提供有关如何使用内存中运算符处理此复杂方案的清晰概念。 首先，让我们看看我们拥有的源数据：  idoc_number，订单ID，idoc_qualifier_org，idoc_org 7738,2364,6,0 7738,2364,7,0 7738,2364,8，mystr1 77...
Spark RDD转换成DataFrame的两种方式
libaowenBlog的博客
08-18 4877
spark官方提供了两种方法实现从RDD转换到DataFrame。 第一种方法是利用反射机制来推断包含特定类型对象的Schema，这种方式适用于对已知的数据结构的RDD转换； 第二种方法通过编程接口构造一个 Schema ，并将其应用在已知的RDD数据中。.........
spark-spark函数详解rdd转换与操作
最新发布
06-28
### 回答1： Spark中的RDD（Resilient Distributed Datasets）是一种分布式的数据结构，它可以被分割成多个分区，每个分区可以在不同的节点上进行计算。RDD提供了一系列的转换和操作函数，可以对RDD进行各种操作。 RDD转换函数包括map、filter、flatMap、union、distinct、groupByKey、reduceByKey、sortByKey等。这些函数可以对RDD进行转换操作，生成新的RDD。 RDD操作函数包括count、collect、reduce、take、foreach等。这些函数可以对RDD进行操作，返回结果或者将结果输出到外部系统。 在使用RDD时，需要注意一些问题，如RDD的惰性计算、RDD的持久化、RDD的分区等。同时，还需要根据实际情况选择合适的RDD转换和操作函数，以达到最优的计算效果。 总之，Spark中的RDD转换和操作函数是非常重要的，掌握它们可以帮助我们更好地使用Spark进行分布式计算。 ### 回答2： Spark是一个基于内存计算的分布式计算框架，可以实现大规模数据集的快速处理。在Spark中，RDD（弹性分布式数据集）是数据处理的核心概念，它是一种可以分区、并行计算和容错的不可变数据结构。而Spark中的函数式编程模型则将RDD的转换与操作都看做是函数的调用，从而简洁明了，易于理解和操作。 在Spark中，解决一个具体问题通常涉及一系列RDD的转换和操作。RDD的转换包括对原有RDD进行过滤、映射、聚合等处理，得到新的RDD；操作则是对新的RDD进行输出、保存、统计、排序等操作。以下介绍几种常见的RDD转换和操作函数。 1. map函数 map函数是一种转换函数，它可以将一个RDD中每个元素通过一个用户定义的函数映射到另一个RDD中，并得到新的RDD。例如，将一个整型RDD中的每个元素都乘以2后得到一个新的整型RDD： ``` val rdd1 = sc.parallelize(Array(1, 2, 3, 4)) val rdd2 = rdd1.map(x => x*2) ``` 2. filter函数 filter函数也是一种转换函数，它可以根据用户定义的条件过滤一个RDD中的元素，并得到一个新的RDD。例如，将一个字符串RDD中长度大于5的元素过滤出来得到一个新的字符串RDD： ``` val rdd1 = sc.parallelize(Array("hello", "world", "spark", "rdd")) val rdd2 = rdd1.filter(x => x.length > 5) ``` 3. reduce函数 reduce函数是一种操作函数，它可以将一个RDD中的元素按照用户定义的函数进行聚合并得到一个结果。例如，将一个整型RDD中的所有元素相加得到一个整数结果： ``` val rdd1 = sc.parallelize(Array(1, 2, 3, 4)) val result = rdd1.reduce((x, y) => x + y) ``` 4. collect函数 collect函数也是一种操作函数，它可以将一个RDD中的所有元素收集起来并输出到Driver端。然而，使用collect函数需要注意RDD的大小，如果RDD很大，就可能会出现内存溢出的情况。例如，将一个整型RDD中的所有元素收集起来并输出到屏幕： ``` val rdd1 = sc.parallelize(Array(1, 2, 3, 4)) val result = rdd1.collect() result.foreach(println) ``` 5. saveAsTextFile函数 saveAsTextFile函数也是一种操作函数，它可以将一个RDD中的所有元素保存到指定的文本文件中。例如，将一个字符串RDD中的所有元素保存到hdfs的一个文本文件中： ``` val rdd1 = sc.parallelize(Array("hello", "world", "spark", "rdd")) rdd1.saveAsTextFile("hdfs://localhost:8020/user/abc/output") ``` 总之，Spark中的RDD转换和操作函数具有弹性、高效、简单等特点，能够满足各种大规模数据处理需求。需要特别注意的是，Spark中的函数式编程模型是基于JVM的，因此要充分利用内存和CPU资源，需要对集群配置和调优进行一定的优化和测试。 ### 回答3： Spark中的RDD（Resilient Distributed Datasets）是分布式的弹性数据集，它可以在大规模集群上并行化地计算，并且提供了一系列的转换和操作函数。其中，Spark提供的Spark函数简单易用，具有高效的数据处理能力，可以帮助开发者快速开发分布式应用程序。 RDD转换函数是将一个RDD转换成另一个RDD的函数，转换后的RDD通常包含了数据处理、筛选和过滤后的新数据集，可以用来接着进行后续的计算。 例如，map函数可以将RDD中的每个元素应用一个函数，然后返回一个新的转换过的RDD： ``` val originalData = sc.parallelize(List(1, 2, 3, 4, 5)) val mappedData = originalData.map(x => x * 2) ``` 这里，map函数将原始数据中的每个元素都乘上了2，返回了一个新的RDD。 除了map函数， 还有flatMap、filter、groupBy等常用的转换函数，都可以帮助我们对RDD做出各种各样的数据处理和转换。 RDD操作函数则是对RDD进行真正的计算操作，例如reduce、count、collect等函数，这些函数会触发Spark的分布式计算引擎执行真正的计算任务。 比如，reduce函数可以将RDD中的所有元素进行聚合，返回一个单一的结果： ``` val originalData = sc.parallelize(List(1, 2, 3, 4, 5)) val reducedData = originalData.reduce(_ + _) ``` 这里，reduce函数将原始数据中的所有元素进行相加操作，返回了一个整数类型的结果。 Spark提供的操作函数非常丰富，从基本的聚合、排序、统计操作，到高级的机器学习和图形处理等操作，开发者可以根据不同的业务需求灵活选择使用。 总之，Spark中的RDD转换和操作函数是分布式数据处理的核心之一，通过这些函数，开发者能够方便地对海量数据进行分布式的计算和处理。同时，Spark也提供了丰富的API和工具，便于开发者进行高效的Spark应用程序开发。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值