转自https://www.cnblogs.com/sharpxiajun/p/5506822.html
本篇文章重要是讲授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 rdd01 = sc.makeRDD(List(1,2,3,4,5,6))
val r01 = rdd01.map
{ x =>
x * x }
println(r01.collect().mkString(","))
/*
Array */
val rdd02 = sc.makeRDD(Array(1,2,3,4,5,6))
val r02 = rdd02.filter
{ x =>
x < 5}
println(r02.collect().mkString(","))
#
parallelize：并行化数据，转化为RDD
data = [1, 2, 3, 4, 5]
distData = sc.parallelize(data,
numSlices=10) #
numSlices为分块数量，依据集群数进行分块
val rdd03 = sc.parallelize(List(1,2,3,4,5,6), 1)
val r03 = rdd03.map
{ x =>
x + 1 }
println(r03.collect().mkString(","))
/*
Array */
val rdd04 = sc.parallelize(List(1,2,3,4,5,6), 1)
val r04 = rdd04.filter
{ x =>
x > 3 }
println(r04.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 rdd01:RDD[Int] = sc.makeRDD(List(1,3,5,3))
val rdd02: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(rdd01.union(rdd02).collect().mkString(","))
println("======union操作======")
/*
intersection操作 */
println("======intersection操作======")
println(rdd01.intersection(rdd02).collect().mkString(","))
println("======intersection操作======")
/*
subtract操作 */
println("======subtract操作======")
println(rdd01.subtract(rdd02).collect().mkString(","))
println("======subtract操作======")
/*
cartesian操作 */
println("======cartesian操作======")
println(rdd01.cartesian(rdd02).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 rdd01 = sc.makeRDD(List(1,2,3,4,5,6))
val r01 = rdd01.map
{ x =>
x * x }
println("===================createDataMethod:makeRDD:List=====================")
println(r01.collect().mkString(","))
println("===================createDataMethod:makeRDD:List=====================")
/*
Array */
val rdd02 = sc.makeRDD(Array(1,2,3,4,5,6))
val r02 = rdd02.filter
{ x =>
x < 5}
println("===================createDataMethod:makeRDD:Array=====================")
println(r02.collect().mkString(","))
println("===================createDataMethod:makeRDD:Array=====================")
/*
应用parallelize创立RDD */
/*
List */
val rdd03 = sc.parallelize(List(1,2,3,4,5,6), 1)
val r03 = rdd03.map
{ x =>
x + 1 }
println("===================createDataMethod:parallelize:List=====================")
println(r03.collect().mkString(","))
println("===================createDataMethod:parallelize:List=====================")
/*
Array */
val rdd04 = sc.parallelize(List(1,2,3,4,5,6), 1)
val r04 = rdd04.filter
{ x =>
x > 3 }
println("===================createDataMethod:parallelize:Array=====================")
println(r04.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 rdd01:RDD[Int] = sc.makeRDD(List(1,3,5,3))
val rdd02: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(rdd01.union(rdd02).collect().mkString(","))
println("======union操作======")
/*
intersection操作 */
println("======intersection操作======")
println(rdd01.intersection(rdd02).collect().mkString(","))
println("======intersection操作======")
/*
subtract操作 */
println("======subtract操作======")
println(rdd01.subtract(rdd02).collect().mkString(","))
println("======subtract操作======")
/*
cartesian操作 */
println("======cartesian操作======")
println(rdd01.cartesian(rdd02).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，这样环境变量才会生效，这个时候程序运行就不会报出毛病了。
另外，可看
