Spack 内置函数

1、Map函数：通过函数传递源的每个元素，并形成新的分布式数据集。

%spark
#并行化集合生成RDD
var data = sc.parallelize(List(10,20,30))
%输出结果
data.collect
%应用map函数并传递表达式
var mapFunc = data.map(x => x+10)
mapFunc.collect

输出：Array[Int] = Array(20, 30, 40)

flatMap: 原RDD中的每一个元素,对应于新RDD里面的一个迭代器。案例 : 将RDD的每个字符串按照逗号进行分割,输出结果。

val flatMapRdd = dataRdd.flatMap(str => str.split(","))

 注意：Map和flatMap这两个函数有什么区别？

Map——文件中的每一行数据返回了一个数组对象；

flatMap——文件中的所有行数据仅返回了一个数组对象。（即：Map映射 + 数据扁平化操作）

2、Filter函数：返回一个新数据集，该数据集是通过选择函数返回true的源元素而形成的。因此，它仅检索满足给定条件的元素。

#过滤掉35
%spark
var data = sc.parallelize(List(10,20,35,40))
var filterFunc = data.filter(x => x!=35)
filterFunc.collect

输出：Array[Int] = Array(10, 20, 40)

3、count函数：返回数据集中存在的元素个数

%spark
var data = sc.parallelize(List(1,2,3,4,5))
var countFunc = data.count()

输出：5

4、Distinct函数：返回提供的数据集中的不同元素。

%spark
var data = sc.parallelize(List(10,10,20,30,40))
var distFunc = data.distinct()
distFunc.collect

5、Union函数：返回一个新数据集，其中包含不同数据集中存在的元素组合。

%spark
var data1 = sc.parallelize(List(10,20))
var data2 = sc.parallelize(List(30,40))
var unionFunc = data1.union(data2)
unionFunc.collect

输出：Array[Int] = Array(10, 20, 30, 40)

6、Intersection函数:返回一个新数据集，其中包含不同数据集中存在的元素的交集

%spark
var data1 = sc.parallelize(List(10,20,30))
var data2 = sc.parallelize(List(30,40))
var IntersectionFunc = data1.intersection(data2)
IntersectionFunc.collect

输出：Array(30)

7、Cartesian函数：生成两个数据集的笛卡尔积，并返回所有可能的对组合。一个数据集的每个元素与另一个数据集的每个元素配对。

%spark
var data1 = sc.parallelize(List(1,2,3))
var data2 = sc.parallelize(List(3,4,5))
var cartesianfunc = data1.cartesian(data2)
cartesianfunc.collect

输出：Array[(Int, Int)] = Array((1,3), (1,4), (1,5), (2,3), (3,3), (2,4), (2,5), (3,4), (3,5))

8、sortByKey函数：维护元素的顺序。它接收键值对(K，V)作为输入，按升序或降序对元素进行排序，并按顺序生成数据集。

%spark
var data = sc.parallelize(Seq(("C",3),("B",2),("D",4),("A",1),("E",5)))
data.collect
#sortByKey默认传入的参数是true，升序的
var sortFun = data.sortByKey(false)
sortFun.collect

输出：Array[(String, Int)] = Array((E,5), (D,4), (C,3), (B,2), (A,1))

9、groupByKey函数：是一种聚合操作，输入（k，value），根据k值进行分类

%spark
var data = sc.parallelize(Seq(("C",3),("C",3),("C",2),("D",4),("A",1),("E",5)))
data.collect
var groupFunc = data.groupByKey()
groupFunc.collect


输出：Array[(String, Iterable[Int])] = Array((D,CompactBuffer(4)), (A,CompactBuffer(1)), (E,CompactBuffer(5)), (C,CompactBuffer(3, 3, 2)))

10、reduceByKey函数：类似于的groupByKey聚合函数，但groupByKey中包含大量shuffle操作，而reduceByKey则能提升性能，因为它不必发送pairRDD中的所有元素，会使用本地合并器先在本地完成基本的聚合操作(先在本地根据key值合并value)，然后发送结果元素。

%spark
var data = sc.parallelize(Seq(("C",3),("C",3),("C",2),("D",4),("A",1),("E",5)))
#需要传入表达式
var reduceFunc = data.reduceByKey((value,x) => (value + x))
reduceFunc.collect

输出：Array[(String, Int)] = Array((D,4), (A,1), (C,8), (E,5))

11、cogroup函数：对不同的数据集执行，比方说，(K，V)和(K，W)并返回(K，(Iterable，Iterable))元组的数据集。此操作也称为groupWith

%spark
var data1 = sc.parallelize(Seq(("A",1),("B",2),("C",3)))
var data2 = sc.parallelize(Seq(("B",4),("C",5),("D",6)))
var cogroupFun = data1.cogroup(data2)
cogroupFun.collect


输出：Array[(String, (Iterable[Int], Iterable[Int]))] = Array((B,(CompactBuffer(2),CompactBuffer(4))), (D,(CompactBuffer(),CompactBuffer(6))), (A,(CompactBuffer(1),CompactBuffer())), (C,(CompactBuffer(3),CompactBuffer(5))))

12、First函数：始终返回数据集的第一个元素。它类似于take(1)。

%spark
var data = sc.parallelize(List(10,20,30))
data.first()

输出：Int = 10

13、take函数：它接收一个整数值(比方说，n)作为参数，并返回数据集的前n个元素的数组。

%spark
var data = sc.parallelize(List(10,20,30))
data.take(2)

输出：Array[Int] = Array(10, 20)

 14、reduce函数：将RDD中元素前两个传给输入函数，产生一个新的return值，新产生的return值与RDD中下一个元素（第三个元素）组成两个元素，再被传给输入函数，直到最后只有一个值为止。

val c = sc.parallelize(1 to 10)
c.reduce((x, y) => x + y)//结果55

 15、substract : 移除一个RDD中的内容。例如：移除RDD1中的RDD2

 val substractRDD = scalaRDD1.subtract(scalaRDD2)

16、sample: 对RDD进行采样, 传入的第一个参数是是否进行替换,第二个参数是采样的比例(返回的结果是随机的)

案例 : 在不替换的前提下,抽取RDD 10%的数据

val sampleRDD = scalaRDD1.sample(false, 0.1)