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

最新推荐文章于 2023-04-18 17:40:36 发布
最新推荐文章于 2023-04-18 17:40:36 发布
阅读量9.3k 收藏 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
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
浅谈Spark RDD API中的Map和Reduce
01-10
RDD是什么？ RDD是Spark中的抽象数据结构类型，任何数据在Spark中都被表示为RDD。从编程的角度来看，RDD可以简单看成是一个数组。和普通数组的区别是，RDD中的数据是分区存储的，这样不同分区的数据就可以分布在不同的机器上，同时可以被并行处理。因此，Spark应用程序所做的无非是把需要处理的数据转换为RDD，然后对RDD进行一系列的变换和操作从而得到结果。本文为第一部分，将介绍Spark RDD中与Map和Reduce相关的API中。 如何创建RDD？ RDD可以从普通数组创建出来，也可以从文件系统或者HDFS中的文件创建出来。 举例：从普通数组创建RDD，里面包含了1到9
Spark RDD详解
01-07
常见疑问 Spark与Apache Hadoop有何关系？ Spark是与Hadoop数据兼容的快速通用处理引擎。它可以通过YARN或Spark的Standalone在Hadoop集群中运行，并且可以处理HDFS、Hbase、Cassandra、Hive和任何Hadoop InputFormat中的数据。它旨在执行批处理(类似于MapReduce)和提供新的工作特性，例如流计算，SparkSQL交互式查询和Machine Learning机器学习等。 我的数据需要容纳在内存中才能使用Spark吗？ 不会。Spark的operators会在不适合内存的情况下将数据溢出到磁盘上，从而使其可以在任何
spark RDD操作详解
09-25
RDD即弹性分布式数据集，有容错机制并可以被并行操作的元素集合，具有只读、分区、容错、高效、无需物化、可以缓存、RDD依赖等特征。RDD只是数据集的抽象，分区内部并不会存储具体的数据。
spark 常见的转化操作和行动操作
BD_fuhong的博客
06-23 981
一、基本RDD 1、转化操作 （1）map（）、flatMap()、filter() scala> val line = sc.textFile("/Users/Desktop/log.txt") line: org.apache.spark.rdd.RDD[String] = /Users/qanfuhong/Desktop/log.txt MapPartitionsRDD[1] ...
常见转换操作和行动操作
wj1298250240的博客
01-11 1437
提取有用信息的例子 定义纯Python方法会降低应用程序的速度，因为Spark需要在Python解释器和JVM之间不断地来回切换。要尽量使用内置的Spark函数 # 需要注意一点。 # 定义纯Python方法会降低应用程序的速度，因为Spark需要在Python解释器和JVM之间不断地来回切换。要尽量使用内置的Spark函数 ​ ​ def extractInformation(row): ...
Spark笔记：RDD基本操作（上）
weixin_34037173的博客
05-18 683
　　本文主要是讲解spark里RDD的基础操作。RDD是spark特有的数据模型，谈到RDD就会提到什么弹性分布式数据集，什么有向无环图，本文暂时不去展开这些高深概念，在阅读本文时候，大家可以就把RDD当作一个数组，这样的理解对我们学习RDD的API是非常有帮助的。本文所有示例代码都是使用scala语言编写的。 　　Spark里的计算都是操作RDD进行，那么学习RDD的第一个问题就是如何构建RD...
RDD算子怎么区分转换算子和行动算子
bing13692468的博客
07-14 1161
textFile 既不是transformation 也不是 action 它是为生成RDD前做准备 算子： 指的就是RDD上的方法。 spark中的算子分为2类： (1)转换算子： transformation： 由RRD 调用方法 返回一个新的RDD (一直存在drive中因为没生成task) ​ 特点: ​ 生成新的rdd ​ lazy执行(不会立刻读取数据记录RDD之间的处理过程) (2)行动算子： action：触发读取数据 , 执行运算的函数 不会返回新的RDD ​ 当触发
Spark计算模型之RDD
aiyin9511的博客
04-17 629
RDD概述 什么是RDD RDD（Resilient Distributed Dataset）叫做弹性分布式数据集，是Spark中最基本的数据抽象，它代表一个不可变、可分区、里面的元素可并行计算的集合。RDD具有数据流模型的特点：自动容错、位置感知性调度和可伸缩性。RDD允许用户在执行多个查询时显式地将数据缓存在内存中，后续的查询能够重用这些数据，这极大地提升了查询速度。 Dataset：一个数据...
【spark rdd编程】求和
我的笔记
07-20 2912
int counter = 0; JavaRDD<Integer> rdd = sc.parallelize(data); // Wrong: Don't do this!! rdd.foreach(x -> counter += x); println("Counter value: " + counter);
详解 Spark RDD 的转换操作与行动操作
weixin_43958974的博客
01-07 4899
前言 本期继续讲解 Spark 核心 RDD 编程部分，内容比较干货也比较长，建议大家先收藏。 学习目标 RDD 的创建 RDD 的转换操作 RDD 的行动操作 惰性求值 1. RDD 的创建 Spark 提供了两种创建 RDD 的方式：对一个集合进行并行化操作和利用外部数据集生成 RDD 。 对一个集合进行并行化操作 Spark 创建 RDD 最简单的方式就是把已经存在的集合传给 parallelize() 方法，不过，这种方式在开发中并不常用，毕竟需要将整个的数据集先放到一个节点.
Spark学习--RDD编码
05-09
Spark中的RDD是一个不可变的分布式对象集合。每个RDD都倍分为多个分区，这些分区运行在集群中的不同节点。RDD可以包含Python、Java、Scala中任意类型的对象，甚至可以包含用户自定义对象，本文主要通过Java实现相关...
大数据管理技术 RDD及其转换操作/行动操作
JxufeCarol的博客
05-01 1342
参考链接： （1）什么是 RDD ？ https://www.jianshu.com/p/6411fff954cf （2）spark的RDD中的action(执行)和transformation(转换)两种操作中常见函数介绍 https://blog.csdn.net/helloxiaozhe/article/details/78481784 （3）常见转换操作和行动操作 https://blog...
大数据-玩转数据-Spark-RDD编程基础-RDD操作（python版）
s_unbo的博客
01-06 912
大数据-玩转数据-Spark-RDD编程基础-RDD操作（python版） RDD操作包括两种类型：转换（Transformation）和行动（Action） 1、转换操作 RDD每次转换操作都会都会产生新的RDD，供下一转换或行动使用，所以叫惰性求值，转换只记录了轨迹，不执行，行动才执行。 常用的RDD转换操作API filter(func) : 筛选出满足func函数的元素，并返回一个新的数据集 map(func):将每个元素传递到函数func中，并将结果返回已个新的数据集 flatMap(func):
spark 面试宝典
2301_76522810的博客
04-18 367
1、什么是宽依赖，什么是窄依赖？哪些算子是宽依赖，哪些是窄依赖？ 窄依赖就是一个父RDD分区对应一个子RDD分区，如map，filter 或者多个父RDD分区对应一个子RDD分区，如co-partioned join宽依赖是一个父RDD分区对应非全部的子RDD分区，如groupByKey，ruduceByKey 或者一个父RDD分区对应全部的子RDD分区，如未经协同划分的join https://www.jianshu.com/p/736a4e628f0f2、Transformation和action算子有
Spark RDD API详解(一) Map和Reduce
热门推荐
jewes的专栏
10-08 11万+
本文用实例介绍Spark中RDD和MapReduce相关的API。
PySpark:键值对RDD及其常用算子
读万卷书 行万里路
05-04 3554
键值对RDD是一种特殊的RDD，注意Spark中并没有这种RDD类型。普通RDD支持的算子都适用于键值对RDD。键值对RDD提供了并行操作各个键或跨节点重新进行数据分组的操作接口。用户可以通过控制键值对RDD在各个节点上的分布情况，大大减少应用的通信开销。...
[Spark] RDD的基本操作
Cindy的博客
07-12 2311
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 5562
RDD创建后就可以在RDD上进行数据处理。RDD支持两种操作：转换（transformation），即从现有的数据集创建一个新的数据集；动作（action），即在数据集上进行计算后，返回一个值给Driver程序。 RDD 的转化操作是返回一个新的 RDD 的操作，比如 map() 和 filter() ，而行动操作则是向驱动器程序返回结果或把结果写入外部系统的操作，会触发实际的计算，比如 coun...
SparkRDD函数详解
布里啾啾迪布利多的博客
03-12 6768
1、RDD操作详解启动spark-shellspark-shell --master spark://node-1:70771.1 基本转换1)      mapmap是对RDD中的每个元素都执行一个指定的函数来产生一个新的RDD。 任何原RDD中的元素在新RDD中都有且只有一个元素与之对应。举例：scala&gt; val a =sc.parallelize(1 to 9, 3)scala&gt...
列举spark常见的转化操作和行动操作
最新发布
06-10
Spark中，常见的转化操作包括： 1. map(func)：对RDD中的每个元素应用一个函数，返回一个新的RDD。 2. filter(func)：对RDD中的每个元素应用一个函数，返回一个新的RDD，其中包含满足条件的元素。 3. flatMap...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值