Spark第二章到第五章全操作代码简解大全

第二章

1.定义与使用常量，变量

(1)常量

程序运行过程中值不会发生变化的量
通过val定义

(2)变量

程序运行过程中值可能发生变化的量
通过var定义

2.使用运算符

3.定义与使用数组

方式1：var gsj: Array[String] = new ArrayString
方式2：var gsj:Array[String] = Array(元素1,元素2,…)
var gsj:Array[String] = Array(“baidu”,“google”,“bing”)
gsj.length
gsj.head
gsj.tail
gsj.isEmpty
gsj.contains(“baidu”)
定义数组gsj
查看长度
查看第一个元素
查看除第一个元素外其他元素
查看是否为空
查看是否包含元素"baidu"

4.定义与使用函数

def gsj(a:Int,b:Int):Int={a+b)
gsj(2,3)
定义两个整数相加的函数
调用函数计算2+3

(1)匿名函数

定义函数时不给出函数名的函数

val gsj=(x:Int,y:Int)=>x+y
gsj(1,2)
定义两个整数相加的匿名函数
调用函数计算1+2

(2)高级函数–函数作为参数

def gsj(f:(Int,Int)=>Int,a:Int,b:Int)=f(a,b)
gsj((a:Int,b:Int)=>a+b,1,2)

(3)高级函数–函数作为返回值

def gsj(length:Double)=(height:Double)=>(length+height)*2
val func=gsj(4)
println(func(5))

(4)函数柯里化

def gsj(a:Int)(b:Int):Int=a+b
gsj(1)(2)

5.if判断

if(布尔表达式){若布尔表达式为true,则执行该语句块}

6.for循环

for(变量<- 集合) {循环语句}

7.定义与使用列表

列表是不可变的
val gsj:List[数据类型]=List(元素1,元素2,…)
gsj.head
gsj.init
gsj.last
gsj.tail
gsj.take(2)
定义集合
获取列表第一个元素
返回所有元素除了最后一个
获取列表的最后一个元素
返回所有元素除了第一个
获取列表前n个元素
val gsj1:List[Int]=List(1,2,3)
val gsj2:List[Int]=List(4,5,6)
gsj1:::gsj2
gsj1.:::(gsj2)
List.concat(gsj1,gsj2)
合并两个列表
val gsj:List[Int]=List(1,2,3)
gsj.contains(3)
判断列表中是否包含某个元素

8.定义与使用集合

集合是没有重复对象的，所有元素都是唯一的

val gsj:Set[Int]=Set(1,2,3,4,5)
gsj.head
gsj.init
gsj.last
gsj.tail
gsj.take(2)
定义集合
获取集合第一个元素
返回所有元素除了最后一个
获取集合的最后一个元素
返回所有元素除了第一个
获取集合前n个元素

9.定义与使用映射

映射是一种可迭代的键值对结构
val gsj:Map[String,Int]=Map(“John”->21,“Betty”->20,“Mike”->22)
gsj.head
gsj.init
gsj.last
gsj.tail
gsj.take(n)
gsj.isEmpty
gsj.keys
gsj.values
定义映射
获取映射第一个元素
返回所有元素除了最后一个
获取映射的最后一个元素
返回所有元素除了第一个
获取映射前n个元素
判断映射的数据是否为空
获取所有的键
获取所有的值

10.定义与使用元组

元组可以包含不同类型的元素
Scala支持的元组最大长度为22
val gsj=(1,3.14,“a”)
val gsj=new Tuple3(1,3.14,“a”)
gsj._1
gsj._3
定义元组的第一种方法
定义元组的第二种方法
访问元组第一个元素
访问元组第三个元素

11.使用函数组合器

(1)map()方法
(2)foreaach()方法
(3)filter()方法
(4)flatten()方法
(5)flatMap()方法
(6)groupBy()方法

第三章

1.从内存中读取数据创建RDD

(1)parallelize()

val gsj = Array(1,2,3,4,5)
val gsjrdd=sc.parallelize(gsj)
gsjrdd.partitions.size
val gsjrdd=sc.parallelize(gsj,4)
gsjrdd.partitions.size
定义一个数组
创建RDD
查看RDD默认分区个数
设置分区个数为4后创建RDD
再次查看RDD分区个数

(2)makeRDD()

val seq = Seq((1,Seq(“iteblog.com”,“sparkhost1.com”)),
((3,Seq(“iteblog.com”,“sparkhost2.com”)),
((2,Seq(“iteblog.com”,“sparkhost3.com”)))
val gsj = sc.makeRDD(seq)
gsj.collect
gsj.partitioner
gsj.partitions.size
gsj.preferredLocations(gsj.partitions(0))
gsj.preferredLocations(gsj.partitions(1))
gsj.preferredLocations(gsj.partitions(2))
定义一个序列seq
创建RDD
查看RDD的值
查看分区个数
根据位置信息查看每一个分区的值

2.从外部存储系统中读取数据创建RDD

(1)通过HDFS文件创建RDD

val gsj = sc.textFile(“/user/root/test.txt”)

(2)通过Linux本地文件创建RDD

val gsj = sc.textFile(“file:///opt/text.txt”)

3.使用map()方法转换数据

val gsj = sc.parallelize(List(1,3,45,3,76))
val sq_gsj=gsj.map(x => x*x)
求平方值

4.使用sortBy()方法进行排序

val gsj =sc.parallelize(List((1,3),(45,3),(7,6))
val sort_gsj = data.sortBy(x => x._2,false,1)

5.使用collect()方法查询数据

sq_gsj.collect
sort_gsj.collect

6.使用flatMap()方法转换数据

val gsj =sc.parallelize(List(“How are you”,“I am fine”,“What about you”))
gsj.collect
gsj.map(x => x.split(" “)).collect
gsj.flatMap(x => s.split(” ")).collect

7.使用take()方法查询某几个值

val gsj = sc.parallelize(1 to 10)
gsj.take(5)

8.使用union()方法合并多个RDD

val gsj1 = sc.parallelize(List((‘a’,1),(‘b’,2),(‘c’,3)))
val gsj2 = sc.parallelize(List((‘a’,1),(‘d’,4),(‘e’,5)))
gsj1.union(gsj2).collect

9.使用filter()方法进行过滤

val gsj1 = sc.parallelize(List((‘a’,1),(‘b’,2),(‘c’,3)))
gsj1.filter(_._2 >1).collect
gsj1.filter(x => x._2 >1).collect

10.使用distinct()方法进行去重

val gsj = sc.makeRDD(List(‘a’,1),(‘a’,1),(‘b’,1),(‘c’,1)))
gsj.distinct().collect

11.使用简单的集合操作

(1)intersection()方法

求出两个RDD的共同元素(求交集)
val gsj1 = sc.parallelize(List((‘a’,1),(‘a’,1),(‘b’,1),(‘c’,1)))
val gsj2 = sc.parallelize(List((‘a’,1),(‘b’,1),(‘d’,1)))
gsj1.intersection(gsj2).collect

(2)subtract()方法

求补集
val gsj1 = sc.parallelize(List((‘a’,1),(‘b’,1),(‘c’,1)))
val gsj2 = sc.parallelize(List((‘d’,1),(‘e’,1),(‘c’,1)))
gsj1.subtract(gsj2).collect
gsj2.subtract(gsj1).collect

(3)cartesian()方法

求笛卡儿积
val gsj1 = sc.makeRDD(List(1,3,5,3))
val gsj2 = sc.makeRDD(List(2,4,5,1))
gsj1.cartesian(gsj2).collect

12.创建键值对RDD

val gsj =sc.parallelize(List(“this is a test”,“how are you”,“I am fine”,“can you tell me”))
val gsjs = gsj.map(x => (x.split(" ")(0),x))
gsjs.collect

13.使用键值对RDD的keys和values方法

val key = gsjs.keys
key.collect
val value = gsjs.values
value.collect

14.使用键值对RDD的reduceByKey()方法

val gsj = sc.parallelize(List((‘a’,1),(‘a’,2),(‘b’,1),(‘c’,1),(‘c’,1)))
val re_gsj = gsj.reduceByKey((a,b) => a+b)
re_gsj.collect

15.使用键值对RDD的groupByKey()方法

val g_gsj = gsj,groupByKey()
g_gsj.collect
g_gsj.map(x => (x._1,x._2.size)).collect

16.使用join()方法连接两个RDD

(1)join()方法

val gsj1 = sc.parallelize(List((‘a’,1),(‘b’,2),(‘c’,3)))
val gsj2 = sc.parallelize(List((‘a’,1),(‘d’,4),(‘e’,5)))
val j_gsj = gsj1.join(gsj2)
j_gsj.collect

(2)rightOuterJoin()方法

右外连接
val right_gsj = gsj1.rightOuterJoin(gsj2)
right_gsj.collect

(3)leftOuterJoin()方法

左外连接
val left_gsj = gsj1.leftOuterJoin(gsj2)
left_gsj.collect

(4)fullOuterJoin()方法

全外连接
val full_gsj = gsj1.fullOuterJoin(gsj2)
full_gsj.collect

17.使用zip()方法组合两个RDD

val gsj1 = sc.makeRDD(1 to 5 ,2)
val gsj2 = sc.makeRDD(seq(“A”,“B”,“C”,“D”,“E”),2)
gsj1.zip(gsj2).collect
gsj2.zip(gsj1).collect

18.使用combineByKey()方法合并相同键的值

combineByKey(createCombiner,mergeValue,mergeCombiners,numPartitions=None)

19.使用lookup()方法查找指定键的值

gsj.lookup(“panda”)
通过lookup()方法查询gsj中键为panda的所有对应值

第四章

第四章代码也看？看下一章了！

第五章

1.创建DataFrame

第1步导包
第2步定义一个样例类
第3步读取文件创建RDD
第4步RDD转成DataFrame

2.查看DataFrame数据

（1）printSchema：输出数据模式

（2）show()：查看数据

gsjDF.show()：显示前20条记录
gsjDF.show(false)：显示所有字符

（3）first()/head()/take()/takeAsList()：获取若干条记录

frist():获取第一条记录
head(n):获取前n条记录
take(n):获取前n条记录
takeAsList(n):获取前n条记录,并以列表的形式展现

(4)collect()/collectAsList():获取所有数据

collect():获取所有数据,返回一个数组
collectAsList():获取所有数据,返回一个列表

3.查询DataFrame查询操作

(1)where()/filter()方法

条件查询

(2)select()/selectExpr()/col()/apply()方法

select():获取指定字段值
selectExpr():对指定字段进行特殊处理

col():获取指定字段值
apply():获取指定字段值

(3)limit()方法

limit():获取指定DataFrame数据的前n条记录

(4)orderBy()/sort()方法

orderBy():根据指定字段对数据进行排序，默认为升序排序
val gsjorderby = gsjDF.orderBy(desc(“id”))
val gsjorderby = gsjDF.orderBy($“id”.desc)
val gsjorderby = gsjDF.orderBy(-user(“id”))
gsjorderby.show()

sort():根据指定字段对数据进行排序
val gsjsort = gsjDF.sort(asc(“id”))
val gsjsort = gsjDF.sort($“id”.asc)
val gsjsort = gsjDF.sort(user(“id”))
gsjsort.show()

(5)groupBy()方法

groupBy():根据指定字段对数据进行分组操作
val gsjgroupby = gsjDF.groupBy(“age”)
val gsjgroupby = gsjDF.groupBy(user(“age”))
val gsjgroupbycount = gsjDF.groupBy(“age”).count
gsjgroupbycount.show()

​