Spark学习之路-1

因工作需要开始学习Spark计算引擎，本系列文章中使用scala语言编写spark程序，在实际开发中可以使用Java，Python或者R语言编写。

1、RDD 弹性分布式数据集

RDD有三种运算：转换（会产生另外一个RDD）、动作（不会产生另外一个RDD）、持久化（对于会重复使用的RDD，可以将RDD持久化在内存中作为后续使用，以提高执行性能）

 

1>、创建intRDD：

val intRDD = sc.parallelize(List(3, 1, 2, 5, 5))

intRDD.collect() // 将数据转换为Array

 

2>、创建stringRDD

val stringRDD = sc.parallelize(List("Apple","Orange","Banana"))

stringRDD.collect()

 

3>、map运算（可以通过传入的函数，将每个元素经过函数运算产生另外一个RDD）

1)具名函数的语句

def addOne(x:Int):Int={

return x+1

}

intRdd.map(addOne).collect()

步骤：先定义addOne函数并传入参数x，此时函数会将x+1再返回

然后将函数名称addOne作为参数传入map命令，map命令会将每一个元素加1，从而产生另外一个RDD

2）匿名函数的语句

intRDD.map(x => x + 1).collect()

lambda表达式方式

3）匿名函数+匿名参数

intRDD.map(_ + 1).collect()

采用下划线_来取代参数 x => x + 1

 

4>、filter运算（可以用户对RDD内每个元素进行筛选，并且产生另外的RDD）

intRDD.filter(x => x < 3).collect()

intRDD.filter(_ < 3).collect()

stringRDD.filter(x => x.contains("ra")).collect()

5>、distinct运算(删除重复的数据)

intRDD.distinct().collect()

stringRDD.distinct().collect()

6>、randomSplit运算（可以将整个集合元素，以随机数的方式按照比例分为多个RDD）

val sRDD = intRDD.randomSplit(Array(0.4,0.6))

运行返回是sRDD数组

sRDD(0).collect()

sRDD(1).collect()

7>、groupBy运算（可以根据传入的匿名函数规则，将数据分为多个Array）

将集合分为奇数和偶数

val gRDD = intRDD.groupBy(x => {if(x % 2 == 0) "even" else "odd"})

8>、多个RDD转换

创建3个RDD

val intRDD1 = sc.parallelize(List(3,1,2,5,5))

val intRDD2 = sc.parallelize(List(5,6))

val intRDD3 = sc.parallelize(List(2,7))

 

union并集

intRDD1.union(intRDD2).union(intRDD3).collect()

(intRDD1 ++ intRDD2 ++ intRDD3).collect()

intersection并集

intRDD1.intersection(intRDD2).collect()

subtract差集

intRDD1.subtract(intRDD2).collect()

cartesian笛卡尔积

intRDD1.cartesian(intRDD2).collect()

9>、基本动作运算

intRDD.first//读取第一条

intRDD.take(2)//读取前几条

intRDD.takeOrdered(3)//按照从小到大排序读取前N条数据

intRDD.takeOrdered(3)(Ordering[Int].reverse)//按照从大到小排序读取前N数据

 

intRDD.stats//统计

intRDD.min//最小值

intRDD.max//最大值

intRDD.stdev//标准差

intRDD.count//计数

intRDD.sum//求和

intRDD.mean//平均

10>、RDD Key-Value基本转换运算

val kvRDD1 = sc.parallelize(List((3,4),(3,6),(5,6),(1,2)))//创建RDD

kvRDD1.keys.collect()//列出所有的Key值 3,3,5,1

kyRDD1.values.collect()//列出所有的value值 4,6,6,2

kvRDD1.filter{case (key,vakue) => key <5}.collect//筛选key<5

kvRDD1.filter{case (key,value) => value <5}.collect//筛选value<5

kvRDD1.mapValues(x => x * x).collect//将每一组Key，Value的value值进行平方运算

kvRDD1.sortByKey(true).collect()//从小到大按照key排序

kvRDD1.sortByKey(false).collect()//从大到小按照key排序

kvRDD1.reduceByKey((x,y)=>x+y)//将具有相同key值的数据合并，合并的方式是按照传入的匿名函数

11>、多个RDD Key-Value转换运算

join//将两个RDD按照相同的key值join起来

leftOuterJoin//从左边的集合对应到右边的集合，并显示所有左边集合中的元素，Some，None

rightOuterJoin

subtractByKey//删除相同key值的数据

 

 

 

2、Spark读取数据

1、读取本地文件

val tf = sc.textFile("/usr/local/test.txt")

（在集群模式下必须保证每台服务器都必须有这个文件）

2、读取hdfs文件

val tf = sc.textFile("hdfs://hadoop01:9000/usr/local/test.txt")