spark中RDD的转化操作和行动操作

最新推荐文章于 2023-08-01 17:10:52 发布
最新推荐文章于 2023-08-01 17:10:52 发布
阅读量9.6k 收藏 7
点赞数
分类专栏： Spark

本文主要是讲解spark里RDD的基础操作。RDD是spark特有的数据模型，谈到RDD就会提到什么弹性分布式数据集，什么有向无环图，本文暂时不去展开这些高深概念，在阅读本文时候，大家可以就把RDD当作一个数组，这样的理解对我们学习RDD的API是非常有帮助的。本文所有示例代码都是使用scala语言编写的。

　　Spark里的计算都是操作RDD进行，那么学习RDD的第一个问题就是如何构建RDD，构建RDD从数据来源角度分为两类：第一类是从内存里直接读取数据，第二类就是从文件系统里读取，当然这里的文件系统种类很多常见的就是HDFS以及本地文件系统了。

　　第一类方式从内存里构造RDD，使用的方法：makeRDD和parallelize方法，如下代码所示：

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/* 使用makeRDD创建RDD */
/* List */
val  rdd 01  =  sc.makeRDD(List( 1 , 2 , 3 , 4 , 5 , 6 ))
val  r 01  =  rdd 01 .map { x  = > x * x }
println(r 01 .collect().mkString( "," ))
/* Array */
val  rdd 02  =  sc.makeRDD(Array( 1 , 2 , 3 , 4 , 5 , 6 ))
val  r 02  =  rdd 02 .filter { x  = > x <  5 }
println(r 02 .collect().mkString( "," ))
 
val  rdd 03  =  sc.parallelize(List( 1 , 2 , 3 , 4 , 5 , 6 ),  1 )
val  r 03  =  rdd 03 .map { x  = > x +  1  }
println(r 03 .collect().mkString( "," ))
/* Array */
val  rdd 04  =  sc.parallelize(List( 1 , 2 , 3 , 4 , 5 , 6 ),  1 )
val  r 04  =  rdd 04 .filter { x  = > x >  3  }
println(r 04 .collect().mkString( "," ))

 

　　大家看到了RDD本质就是一个数组，因此构造数据时候使用的是List（链表）和Array（数组）类型。

　　第二类方式是通过文件系统构造RDD，代码如下所示：

1
2
3
val  rdd : RDD[String]  =  sc.textFile( "file:///D:/sparkdata.txt" ,  1 )
val  r : RDD[String]  =  rdd.flatMap { x  = > x.split( "," ) }
println(r.collect().mkString( "," ))

　　这里例子使用的是本地文件系统，所以文件路径协议前缀是file://。

　　构造了RDD对象了，接下来就是如何操作RDD对象了，RDD的操作分为转化操作（transformation）和行动操作（action），RDD之所以将操作分成这两类这是和RDD惰性运算有关，当RDD执行转化操作时候，实际计算并没有被执行，只有当RDD执行行动操作时候才会促发计算任务提交，执行相应的计算操作。区别转化操作和行动操作也非常简单，转化操作就是从一个RDD产生一个新的RDD操作，而行动操作就是进行实际的计算。

　　下面是RDD的基础操作API介绍：

操作类型

函数名

作用

转化操作

map()

参数是函数，函数应用于RDD每一个元素，返回值是新的RDD

flatMap()

参数是函数，函数应用于RDD每一个元素，将元素数据进行拆分，变成迭代器，返回值是新的RDD

filter()

参数是函数，函数会过滤掉不符合条件的元素，返回值是新的RDD

distinct()

没有参数，将RDD里的元素进行去重操作

union()

参数是RDD，生成包含两个RDD所有元素的新RDD

intersection()

参数是RDD，求出两个RDD的共同元素

subtract()

参数是RDD，将原RDD里和参数RDD里相同的元素去掉

cartesian()

参数是RDD，求两个RDD的笛卡儿积

行动操作

collect()

返回RDD所有元素

count()

RDD里元素个数

countByValue()

各元素在RDD中出现次数

reduce()

并行整合所有RDD数据，例如求和操作

fold(0)(func)

和reduce功能一样，不过fold带有初始值

aggregate(0)(seqOp,combop)

和reduce功能一样，但是返回的RDD数据类型和原RDD不一样

foreach(func)

对RDD每个元素都是使用特定函数

　　下面是以上API操作的示例代码，如下：

　　转化操作：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
val  rddInt : RDD[Int]  =  sc.makeRDD(List( 1 , 2 , 3 , 4 , 5 , 6 , 2 , 5 , 1 ))
val  rddStr : RDD[String]  =  sc.parallelize(Array( "a" , "b" , "c" , "d" , "b" , "a" ),  1 )
val  rddFile : RDD[String]  =  sc.textFile(path,  1 )
 
val  rdd 01 : RDD[Int]  =  sc.makeRDD(List( 1 , 3 , 5 , 3 ))
val  rdd 02 : RDD[Int]  =  sc.makeRDD(List( 2 , 4 , 5 , 1 ))
 
/* map操作 */
println( "======map操作======" )
println(rddInt.map(x  = > x +  1 ).collect().mkString( "," ))
println( "======map操作======" )
/* filter操作 */
println( "======filter操作======" )
println(rddInt.filter(x  = > x >  4 ).collect().mkString( "," ))
println( "======filter操作======" )
/* flatMap操作 */
println( "======flatMap操作======" )
println(rddFile.flatMap { x  = > x.split( "," ) }.first())
println( "======flatMap操作======" )
/* distinct去重操作 */
println( "======distinct去重======" )
println(rddInt.distinct().collect().mkString( "," ))
println(rddStr.distinct().collect().mkString( "," ))
println( "======distinct去重======" )
/* union操作 */
println( "======union操作======" )
println(rdd 01 .union(rdd 02 ).collect().mkString( "," ))
println( "======union操作======" )
/* intersection操作 */
println( "======intersection操作======" )
println(rdd 01 .intersection(rdd 02 ).collect().mkString( "," ))
println( "======intersection操作======" )
/* subtract操作 */
println( "======subtract操作======" )
println(rdd 01 .subtract(rdd 02 ).collect().mkString( "," ))
println( "======subtract操作======" )
/* cartesian操作 */
println( "======cartesian操作======" )
println(rdd 01 .cartesian(rdd 02 ).collect().mkString( "," ))
println( "======cartesian操作======" )

　　行动操作代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
val  rddInt : RDD[Int]  =  sc.makeRDD(List( 1 , 2 , 3 , 4 , 5 , 6 , 2 , 5 , 1 ))
val  rddStr : RDD[String]  =  sc.parallelize(Array( "a" , "b" , "c" , "d" , "b" , "a" ),  1 )
 
/* count操作 */
println( "======count操作======" )
println(rddInt.count())
println( "======count操作======" )  
/* countByValue操作 */
println( "======countByValue操作======" )
println(rddInt.countByValue())
println( "======countByValue操作======" )
/* reduce操作 */
println( "======countByValue操作======" )
println(rddInt.reduce((x ,y)  = > x + y))
println( "======countByValue操作======" )
/* fold操作 */
println( "======fold操作======" )
println(rddInt.fold( 0 )((x ,y)  = > x + y))
println( "======fold操作======" )
/* aggregate操作 */
println( "======aggregate操作======" )
val  res : (Int,Int)  =  rddInt.aggregate(( 0 , 0 ))((x,y)  = > (x. _ 1  + x. _ 2 ,y),(x,y)  = > (x. _ 1  + x. _ 2 ,y. _ 1  + y. _ 2 ))
println(res. _ 1  +  ","  + res. _ 2 )
println( "======aggregate操作======" )
/* foeach操作 */
println( "======foeach操作======" )
println(rddStr.foreach { x  = > println(x) })
println( "======foeach操作======" )

　　RDD操作暂时先学习到这里，剩下的内容在下一篇里再谈了，下面我要说说如何开发spark，安装spark的内容我后面会使用专门的文章进行讲解，这里我们假设已经安装好了spark，那么我们就可以在已经装好的spark服务器上使用spark-shell进行与spark交互的shell，这里我们直接可以敲打代码编写spark程序。但是spark-shell毕竟使用太麻烦，而且spark-shell一次只能使用一个用户，当另外一个用户要使用spark-shell就会把前一个用户踢掉，而且shell也没有IDE那种代码补全，代码校验的功能，使用起来很是痛苦。

　　不过spark的确是一个神奇的框架，这里的神奇就是指spark本地开发调试非常简单，本地开发调试不需要任何已经装好的spark系统，我们只需要建立一个项目，这个项目可以是java的也可以是scala，然后我们将spark-assembly-1.6.1-hadoop2.6.0.jar这样的jar放入项目的环境里，这个时候我们就可以在本地开发调试spark程序了。

　　大家请看我们装有scala插件的eclipse里的完整代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
package  cn.com.sparktest
 
import  org.apache.spark.SparkConf
import  org.apache.spark.SparkConf
import  org.apache.spark.SparkContext
import  org.apache.spark.rdd.RDD
 
object  SparkTest {
   val  conf : SparkConf  =  new  SparkConf().setAppName( "xtq" ).setMaster( "local[2]" )
   val  sc : SparkContext  =  new  SparkContext(conf)
   
   /**
    * 创建数据的方式--从内存里构造数据(基础)
    */
   def  createDataMethod() : Unit  =  {
     /* 使用makeRDD创建RDD */
     /* List */
     val  rdd 01  =  sc.makeRDD(List( 1 , 2 , 3 , 4 , 5 , 6 ))
     val  r 01  =  rdd 01 .map { x  = > x * x }
     println( "===================createDataMethod:makeRDD:List=====================" )
     println(r 01 .collect().mkString( "," ))
     println( "===================createDataMethod:makeRDD:List=====================" )
     /* Array */
     val  rdd 02  =  sc.makeRDD(Array( 1 , 2 , 3 , 4 , 5 , 6 ))
     val  r 02  =  rdd 02 .filter { x  = > x <  5 }
     println( "===================createDataMethod:makeRDD:Array=====================" )
     println(r 02 .collect().mkString( "," ))
     println( "===================createDataMethod:makeRDD:Array=====================" )
     
     /* 使用parallelize创建RDD */
     /* List */
     val  rdd 03  =  sc.parallelize(List( 1 , 2 , 3 , 4 , 5 , 6 ),  1 )
     val  r 03  =  rdd 03 .map { x  = > x +  1  }
     println( "===================createDataMethod:parallelize:List=====================" )
     println(r 03 .collect().mkString( "," ))
     println( "===================createDataMethod:parallelize:List=====================" )
     /* Array */
     val  rdd 04  =  sc.parallelize(List( 1 , 2 , 3 , 4 , 5 , 6 ),  1 )
     val  r 04  =  rdd 04 .filter { x  = > x >  3  }
     println( "===================createDataMethod:parallelize:Array=====================" )
     println(r 04 .collect().mkString( "," ))
     println( "===================createDataMethod:parallelize:Array=====================" )
   }
   
   /**
    * 创建Pair Map
    */
   def  createPairRDD() : Unit  =  {
     val  rdd : RDD[(String,Int)]  =  sc.makeRDD(List(( "key01" , 1 ),( "key02" , 2 ),( "key03" , 3 )))
     val  r : RDD[String]  =  rdd.keys
     println( "===========================createPairRDD=================================" )
     println(r.collect().mkString( "," ))
     println( "===========================createPairRDD=================================" )
   }
   
   /**
    * 通过文件创建RDD
    * 文件数据：
    *    key01,1,2.3
           key02,5,3.7
       key03,23,4.8
       key04,12,3.9
       key05,7,1.3
    */
   def  createDataFromFile(path : String) : Unit  =  {
     val  rdd : RDD[String]  =  sc.textFile(path,  1 )
     val  r : RDD[String]  =  rdd.flatMap { x  = > x.split( "," ) }
     println( "=========================createDataFromFile==================================" )
     println(r.collect().mkString( "," ))
     println( "=========================createDataFromFile==================================" )
   }
   
   /**
    * 基本的RDD操作
    */
   def  basicTransformRDD(path : String) : Unit  =  {
     val  rddInt : RDD[Int]  =  sc.makeRDD(List( 1 , 2 , 3 , 4 , 5 , 6 , 2 , 5 , 1 ))
     val  rddStr : RDD[String]  =  sc.parallelize(Array( "a" , "b" , "c" , "d" , "b" , "a" ),  1 )
     val  rddFile : RDD[String]  =  sc.textFile(path,  1 )
     
     val  rdd 01 : RDD[Int]  =  sc.makeRDD(List( 1 , 3 , 5 , 3 ))
     val  rdd 02 : RDD[Int]  =  sc.makeRDD(List( 2 , 4 , 5 , 1 ))
 
     /* map操作 */
     println( "======map操作======" )
     println(rddInt.map(x  = > x +  1 ).collect().mkString( "," ))
     println( "======map操作======" )
     /* filter操作 */
     println( "======filter操作======" )
     println(rddInt.filter(x  = > x >  4 ).collect().mkString( "," ))
     println( "======filter操作======" )
     /* flatMap操作 */
     println( "======flatMap操作======" )
     println(rddFile.flatMap { x  = > x.split( "," ) }.first())
     println( "======flatMap操作======" )
     /* distinct去重操作 */
     println( "======distinct去重======" )
     println(rddInt.distinct().collect().mkString( "," ))
     println(rddStr.distinct().collect().mkString( "," ))
     println( "======distinct去重======" )
     /* union操作 */
     println( "======union操作======" )
     println(rdd 01 .union(rdd 02 ).collect().mkString( "," ))
     println( "======union操作======" )
     /* intersection操作 */
     println( "======intersection操作======" )
     println(rdd 01 .intersection(rdd 02 ).collect().mkString( "," ))
     println( "======intersection操作======" )
     /* subtract操作 */
     println( "======subtract操作======" )
     println(rdd 01 .subtract(rdd 02 ).collect().mkString( "," ))
     println( "======subtract操作======" )
     /* cartesian操作 */
     println( "======cartesian操作======" )
     println(rdd 01 .cartesian(rdd 02 ).collect().mkString( "," ))
     println( "======cartesian操作======" )   
   }
   
   /**
    * 基本的RDD行动操作
    */
   def  basicActionRDD() : Unit  =  {
     val  rddInt : RDD[Int]  =  sc.makeRDD(List( 1 , 2 , 3 , 4 , 5 , 6 , 2 , 5 , 1 ))
     val  rddStr : RDD[String]  =  sc.parallelize(Array( "a" , "b" , "c" , "d" , "b" , "a" ),  1 )
     
     /* count操作 */
     println( "======count操作======" )
     println(rddInt.count())
     println( "======count操作======" )  
     /* countByValue操作 */
     println( "======countByValue操作======" )
     println(rddInt.countByValue())
     println( "======countByValue操作======" )
     /* reduce操作 */
     println( "======countByValue操作======" )
     println(rddInt.reduce((x ,y)  = > x + y))
     println( "======countByValue操作======" )
     /* fold操作 */
     println( "======fold操作======" )
     println(rddInt.fold( 0 )((x ,y)  = > x + y))
     println( "======fold操作======" )
     /* aggregate操作 */
     println( "======aggregate操作======" )
     val  res : (Int,Int)  =  rddInt.aggregate(( 0 , 0 ))((x,y)  = > (x. _ 1  + x. _ 2 ,y),(x,y)  = > (x. _ 1  + x. _ 2 ,y. _ 1  + y. _ 2 ))
     println(res. _ 1  +  ","  + res. _ 2 )
     println( "======aggregate操作======" )
     /* foeach操作 */
     println( "======foeach操作======" )
     println(rddStr.foreach { x  = > println(x) })
     println( "======foeach操作======" )   
   }
   
   def  main(args :  Array[String]) :  Unit  =  {
     println(System.getenv( "HADOOP_HOME" ))
     createDataMethod()
     createPairRDD()
     createDataFromFile( "file:///D:/sparkdata.txt" )
     basicTransformRDD( "file:///D:/sparkdata.txt" )
     basicActionRDD()
     /*打印结果*/
     /*D://hadoop
===================createDataMethod:makeRDD:List=====================
1,4,9,16,25,36
===================createDataMethod:makeRDD:List=====================
===================createDataMethod:makeRDD:Array=====================
1,2,3,4
===================createDataMethod:makeRDD:Array=====================
===================createDataMethod:parallelize:List=====================
2,3,4,5,6,7
===================createDataMethod:parallelize:List=====================
===================createDataMethod:parallelize:Array=====================
4,5,6
===================createDataMethod:parallelize:Array=====================
===========================createPairRDD=================================
key01,key02,key03
===========================createPairRDD=================================
key01,1,2.3,key02,5,3.7,key03,23,4.8,key04,12,3.9,key05,7,1.3
=========================createDataFromFile==================================
2,3,4,5,6,7,3,6,2
======map操作======
======filter操作======
5,6,5
======filter操作======
======flatMap操作======
key01
======flatMap操作======
======distinct去重======
4,6,2,1,3,5
======distinct去重======
======union操作======
1,3,5,3,2,4,5,1
======union操作======
======intersection操作======
1,5
======intersection操作======
======subtract操作======
3,3
======subtract操作======
======cartesian操作======
(1,2),(1,4),(3,2),(3,4),(1,5),(1,1),(3,5),(3,1),(5,2),(5,4),(3,2),(3,4),(5,5),(5,1),(3,5),(3,1)
======cartesian操作======
======count操作======
9
======count操作======
======countByValue操作======
Map(5 -> 2, 1 -> 2, 6 -> 1, 2 -> 2, 3 -> 1, 4 -> 1)
======countByValue操作======
======countByValue操作======
29
======countByValue操作======
======fold操作======
29
======fold操作======
======aggregate操作======
19,10
======aggregate操作======
======foeach操作======
a
b
c
d
b
a
======foeach操作======*/
   }
}

　　Spark执行时候我们需要构造一个SparkContenxt的环境变量，构造环境变量时候需要构造一个SparkConf对象，例如代码：setAppName("xtq").setMaster("local[2]")

　　appName就是spark任务名称，master为local[2]是指使用本地模式，启动2个线程完成spark任务。

　　在eclipse里运行spark程序时候，会报出如下错误：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
java.io.IOException :  Could not locate executable  null \bin\winutils.exe in the Hadoop binaries.
     at org.apache.hadoop.util.Shell.getQualifiedBinPath(Shell.java : 355 )
     at org.apache.hadoop.util.Shell.getWinUtilsPath(Shell.java : 370 )
     at org.apache.hadoop.util.Shell.<clinit>(Shell.java : 363 )
     at org.apache.hadoop.util.StringUtils.<clinit>(StringUtils.java : 79 )
     at org.apache.hadoop.security.Groups.parseStaticMapping(Groups.java : 104 )
     at org.apache.hadoop.security.Groups.<init>(Groups.java : 86 )
     at org.apache.hadoop.security.Groups.<init>(Groups.java : 66 )
     at org.apache.hadoop.security.Groups.getUserToGroupsMappingService(Groups.java : 280 )
     at org.apache.hadoop.security.UserGroupInformation.initialize(UserGroupInformation.java : 271 )
     at org.apache.hadoop.security.UserGroupInformation.ensureInitialized(UserGroupInformation.java : 248 )
     at org.apache.hadoop.security.UserGroupInformation.loginUserFromSubject(UserGroupInformation.java : 763 )
     at org.apache.hadoop.security.UserGroupInformation.getLoginUser(UserGroupInformation.java : 748 )
     at org.apache.hadoop.security.UserGroupInformation.getCurrentUser(UserGroupInformation.java : 621 )
     at org.apache.spark.util.Utils$$anonfun$getCurrentUserName$ 1 .apply(Utils.scala : 2160 )
     at org.apache.spark.util.Utils$$anonfun$getCurrentUserName$ 1 .apply(Utils.scala : 2160 )
     at scala.Option.getOrElse(Option.scala : 120 )
     at org.apache.spark.util.Utils$.getCurrentUserName(Utils.scala : 2160 )
     at org.apache.spark.SparkContext.<init>(SparkContext.scala : 322 )
     at cn.com.sparktest.SparkTest$.<init>(SparkTest.scala : 10 )
     at cn.com.sparktest.SparkTest$.<clinit>(SparkTest.scala)
     at cn.com.sparktest.SparkTest.main(SparkTest.scala)

　　该错误不会影响程序的运算，但总是让人觉得不舒服，这个问题是因为spark运行依赖于hadoop，可是在window下其实是无法安装hadoop，只能使用cygwin模拟安装，而新版本的hadoop在windows下使用需要使用winutils.exe，解决这个问题很简单，就是下载一个winutils.exe，注意下自己操作系统是32位还是64位，找到对应版本，然后放置在这样的目录下：

　　D:\hadoop\bin\winutils.exe

　　然后再环境变量里定义HADOOP_HOME= D:\hadoop

　　环境变量的改变要重启eclipse，这样环境变量才会生效，这个时候程序运行就不会报出错误了。

转自：http://www.cnblogs.com/sharpxiajun/p/5506822.html

YQlakers
关注
专栏目录
Spark入门（四）：RDD基本操作
源码有毒的专栏
08-14 2655
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】Spark RDD操作、转化操作和行动操作
晚风中的自由
11-03 348
一、创建RDD 1、外部数据集（external datasets） var rdd = sc.textFile("hdfs://hadoop-senior.ibeifeng.com:8020/user/root/mapreduce/wordcount/input/wc.input") rdd.collect res6: Array[String] = Array(hadoop hive, ...
Spark笔记：RDD基本操作（上）
weixin_34037173的博客
05-18 711
　　本文主要是讲解spark里RDD的基础操作。RDD是spark特有的数据模型，谈到RDD就会提到什么弹性分布式数据集，什么有向无环图，本文暂时不去展开这些高深概念，在阅读本文时候，大家可以就把RDD当作一个数组，这样的理解对我们学习RDD的API是非常有帮助的。本文所有示例代码都是使用scala语言编写的。 　　Spark里的计算都是操作RDD进行，那么学习RDD的第一个问题就是如何构建RD...
04、常用RDD操作整理
weixin_34019929的博客
07-31 224
常用Transformation 注：某些函数只有PairRDD只有，而普通的RDD则没有，比如gropuByKey、reduceByKey、sortByKey、join、cogroup等函数要根据Key进行分组或直接操作 RDD基本转换： RDD[U] map(f: T =&gt; U) T：原RDD中元素类...
[Spark] RDD的基本操作
Cindy的博客
07-12 2431
1. RDD的基本操作RDD支持两种类型的操作：1) transformations，转换。从一个RDD转换成另外一个RDD（RDD是不可变的）。   例如：map函数，对RDD里每一个元素做同一件事，将一个RDD转换成另外一个RDD   RDDA（1，2，3，4，5）        map( +1 )        RDDB（2，3，4，5，6）2) actions，操作。它会在数据集上计算后返...
RDD的两种操作（Transformation和Action）
SunnyRivers
03-31 5805
RDD创建后就可以在RDD上进行数据处理。RDD支持两种操作：转换（transformation），即从现有的数据集创建一个新的数据集；动作（action），即在数据集上进行计算后，返回一个值给Driver程序。 RDD 的转化操作是返回一个新的 RDD 的操作，比如 map() 和 filter() ，而行动操作则是向驱动器程序返回结果或把结果写入外部系统的操作，会触发实际的计算，比如 coun...
spark——详解rdd常用的转化和行动操作
TechFlow的博客
04-19 1656
本文始发于个人公众号：TechFlow，原创不易，求个关注 今天是spark第三篇文章，我们继续来看RDD的一些操作。 我们前文说道在spark当中RDD的操作可以分为两种，一种是转化操作(transformation），另一种是行动操作(action)。在转化操作当中，spark不会为我们计算结果，而是会生成一个新的RDD节点，记录下这个操作。只有在行动操作执行的时候，spark才会从头开始计...
Spark RDD简介与操作
最新发布
weixin_62121679的博客
08-01 514
在Spark中，RDD可以看作是一个对象，它本身运行于内存中，如读文件是一个RDD，对文件计算是一个RDD，结果集也是一个RDD。在Spark中，RDD可以看作是一个对象，它本身运行于内存中，可以用于读文件、对文件计算、结果集等操作。在Spark中，RDD是一个并行集合，它包含多个分片，每个分片可以在不同的计算节点上并行处理。然后，我们对RDD进行转换和计算操作，并输出结果。在Scala中，Spark的RDD API提供了许多转换操作（transformations），用于对RDD进行转换和计算。
Day67_Spark(二）Spark RDD操作
qq_36972345的博客
10-20 1085
课程大纲 课程内容 学习效果 掌握目标 Spark执行流程 Wordcount执行流程 掌握 Spark作业提交流程 掌握 RDD操作 RDD初始化 掌握 RDD操作 ...
Spark RDD(一) RDD的创建和转化操作
the_conquer_zzy的专栏
05-02 627
Spark RDD(一) RDD的创建和转化操作 RDD 有几个特点 不可变 容错 并行数据结构 内存中计算 数据分区和存放 丰富的操作函数 RDD 的操作行为可以分为两类：转换和行为。 转换是一个延迟操作，返回的结果是另外一个RDD。 行为是另一种操作，会触发转换逻辑。行为的结果一般是返回一个结果，或者把结果写到磁盘。 创建RDD 有3种方式： (1) parallelize一个object...
Spark RDD操作之基本转换
Black&White的专栏
02-23 404
map map是对RDD中的每个元素都执行一个指定的函数来产生一个新的RDD。 任何原RDD中的元素在新RDD中都有且只有一个元素与之对应。 举例： scala> val a = sc.parallelize(1 to 9, 3) scala> val b = a.map(x => x*2) scala> a.collect res10: Array[Int] = Arra...
RDD操作详解（一）基本转换
热门推荐
Running_Tiger的博客
03-06 1万+
RDD操作详解（一）基本转换 启动spark-shell spark-shell --master spark://node-1:7077 1. map map是对RDD中的每个元素都执行一个指定的函数来产生一个新的RDD。 任何原RDD中的元素在新RDD中都有且只有一个元素与之对应。 举例： scala&gt; val a = sc.parallelize(1 to 9...
spark 之RDD操作
永远飞翔的鸟
02-15 705
转载：https://www.cnblogs.com/nolonely/p/5402698.html RDD操作 1.对一个数据为{1，2，3，3}的RDD进行基本的RDD转化操作 函数名 目的 示例 结果 map() 函数应用于RDD中的每个元素 rdd.map(x=>x+1) {2,3,4,4} flatMap() ...
详解 Spark RDD 的转换操作与行动操作
weixin_43958974的博客
01-07 5580
前言 本期继续讲解 Spark 核心 RDD 编程部分，内容比较干货也比较长，建议大家先收藏。 学习目标 RDD 的创建 RDD 的转换操作 RDD 的行动操作 惰性求值 1. RDD 的创建 Spark 提供了两种创建 RDD 的方式：对一个集合进行并行化操作和利用外部数据集生成 RDD 。 对一个集合进行并行化操作 Spark 创建 RDD 最简单的方式就是把已经存在的集合传给 parallelize() 方法，不过，这种方式在开发中并不常用，毕竟需要将整个的数据集先放到一个节点.
Scala——RDD创建，转换操作和行动操作
weixin_46880810的博客
10-06 1793
RDD val list = List(“i like hadoop”,“spark is fast”,“i like spark”) val rdd = sc.parallelize(list) val rdd1 = rdd.flatMap(line => line.split(" ")) val rdd2 = rdd1.map(line => (line,1)) val rdd3 = rdd2.reduceByKey((a,b) => a+b) rdd3.collect ...
RDD转换算子和行动算子的区别
JaneRoad
02-21 3146
textFile 既不是transformation 也不是 action 它是为生成RDD前做准备 算子： 指的就是RDD上的方法。 spark中的算子分为2类...
大数据-玩转数据-Spark-RDD编程基础-RDD操作（python版）
s_unbo的博客
01-06 1036
大数据-玩转数据-Spark-RDD编程基础-RDD操作（python版） RDD操作包括两种类型：转换（Transformation）和行动（Action） 1、转换操作 RDD每次转换操作都会都会产生新的RDD，供下一转换或行动使用，所以叫惰性求值，转换只记录了轨迹，不执行，行动才执行。 常用的RDD转换操作API filter(func) : 筛选出满足func函数的元素，并返回一个新的数据集 map(func):将每个元素传递到函数func中，并将结果返回已个新的数据集 flatMap(func):
RDD算子怎么区分转换算子和行动算子
bing13692468的博客
07-14 1270
textFile 既不是transformation 也不是 action 它是为生成RDD前做准备 算子： 指的就是RDD上的方法。 spark中的算子分为2类： (1)转换算子： transformation： 由RRD 调用方法 返回一个新的RDD (一直存在drive中因为没生成task) ​ 特点: ​ 生成新的rdd ​ lazy执行(不会立刻读取数据记录RDD之间的处理过程) (2)行动算子： action：触发读取数据 , 执行运算的函数 不会返回新的RDD ​ 当触发
列举spark常见的转化操作和行动操作
06-10
Spark中，常见的转化操作包括： 1. map(func)：对RDD中的每个元素应用一个函数，返回一个新的RDD。 2. filter(func)：对RDD中的每个元素应用一个函数，返回一个新的RDD，其中包含满足条件的元素。 3. flatMap(func)：对RDD中的每个元素应用一个函数，将返回的迭代器中的所有元素组合成一个新的RDD。 4. groupByKey()：对(K, V)格式的RDD进行分组，返回一个新的(K, Iterable<V>)格式的RDD。 5. reduceByKey(func)：对(K, V)格式的RDD进行分组，并对每组的V值进行reduce操作，返回一个新的(K, V)格式的RDD。 6. sortByKey()：对(K, V)格式的RDD按照K进行排序，返回一个新的(K, V)格式的RDD。 常见的行动操作包括： 1. count()：返回RDD中元素的个数。 2. collect()：以数组的形式返回RDD中的所有元素。 3. reduce(func)：对RDD中的所有元素进行reduce操作，返回一个单独的结果。 4. first()：返回RDD中的第一个元素。 5. take(n)：返回RDD中的前n个元素。 6. foreach(func)：对RDD中的每个元素应用一个函数，通常用于数据输出等操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值