spark笔记二之Spark程序模型Transformation算子与action算子

Spark程序模型

textFile读取文件

val file=sc.textFile(“hdfs://192.168.192.137:9000/data/t1.csv”)
filter函数过滤带“a”的行，输出errors（errors也是一个RDD）

filter(func)

val errors=file.filter(line=>line.contains(“a”))
count函数返回带“a”的行的行数：
errors.count()

RDD的两种操作算子Transformation（变换）与Action（行动）
Transformation操作是延迟计算的
Action算子会触发Spark提交作业（Job），并将数据输出到Spark系统
Spark算子分类及功能

Value型Transformation算子

parallelize创建RDD

从普通数组创建RDD，里面包含了1到9这9个数字，它们分别在3个分区中
val a = sc.parallelize(1 to 9, 3)
val rdd = sc.parallelize(List((‘a’,1),(‘a’,2)))
val file=sc.textFile(“hdfs://192.168.192.137:9000/data/t2.txt”)

map

map将原来RDD的每个数据项通过map中的用户自定义函数f映射转变为一个新的元素MappedRDD（this，sc.clean（f））f:T=>U

mapPartitions

mapPartitions的输入函数是应用于每个分区
val word=file.map(x => (x,1)) #map(f) 传入的参数为函数f，f的格式可以为T=>U x => (x,1)意思是原来的x转化为x和1两个新元素作为一个数据项
val word=file.map(_.toDouble) #进行数值运算的时候必须先转化成double型
word.collect()
val word2=word.map(x =>x+1)
val word2=word.map(x =>x*2)
word2.collect()

mapWith

mapWith第一个函数把RDDf分区索引(从0开始)作为输入，第二个函数f是把二元组(T, A)作为输入（其中T为原RDD中的元素，A为第一个函数的输出），输出类型为U
def mapWith[A: ClassTag, U: ](constructA: Int => A, preservesPartitioning: Boolean = false)(f: (T, A) => U): RDD[U]
val x = sc.parallelize(List(1,2,3,4,5,6,7,8,9,10), 3)
x.mapWith(a => a * 10)((a, b) => (a,b + 2)).collect
//0*10+2 1*10+2 2*10+2
Array((1,2), (2,2), (3,2), (4,12), (5,12), (6,12), (7,22), (8,22), (9,22), (10,22))

flatMap

flatMap(func)将原来RDD中的每个元素通过函数f转换为新的元素将生成的RDD的每个集合中的元素合并为一个集合FlatMappedRDD（this，sc.clean（f））
多个集合形成为RDD中的数据项
与map类似，区别是原RDD中的元素经map处理后只能生成一个元素，而原RDD中的元素经flatmap处理后可生成多个元素来构建新RDD
val file=sc.textFile(“hdfs://192.168.192.137:9000/data/t2.txt”)
file.collect()
val count = file.flatMap(line=>(line.split(“,”)))
count.collect()
val a = sc.parallelize(1 to 4, 2)
val b = a.flatMap(x => 1 to x)
b.collect

flatMapWith

flatMapWith一个函数把partitionIndex作为输入，输出是一个新类型A；另外一个函数是以二元组（T,A）作为输入，输出为一个序列，这些序列里面的元素组成了新的RDD
val a = sc.parallelize(List(1,2,3,4,5,6,7,8,9), 3)
a.flatMapWith(x => x, true)((x, y) => List(y, x)).collect
Array[Int] = Array(0, 1, 0, 2, 0, 3, 1, 4, 1, 5, 1, 6, 2, 7, 2,8, 2, 9)

mapPartitions(func)

mapPartitions(func)函数获取到每个分区的迭代器，在函数中通过这个分区整体的迭代器对整个分区的元素进行操作
val word=file.map(_.toDouble)
val word1=word.mapPartitions(iter=>iter.filter(_>=3))
word1.collect()

glom()

glom()函数将每个分区形成一个数组
val word1=word.glom()
word1.collect()

union(otherDataset)

union(otherDataset)函数时需要保证两个RDD元素的数据类型相同，返回的RDD数据类型和被合并的RDD元素数据类型相同，并不进行去重操作，保存所有元素。
如果想去重，可以使用distinct()
val word=file.map(_.toDouble)
val word1=word.mapPartitions(iter=>iter.filter(_>=3))
val word2=word.map(x =>x+1)
word1.union(word2).collect()
word1.union(word2).distinct().collect()

cartesian(otherDataset)

cartesian(otherDataset)对两个RDD内的所有元素进行笛卡尔积操作
例如V1和另一个RDD中的W1、 W2、 Q5进行笛卡尔积运算形成（V1，W1）、 （V1，W2）、 （V1，Q5）
word1.cartesian(word2).collect()

reduce(func)

reduce(func)属于action函数reduce将RDD中元素两两传递给输入函数，同时产生一个新的值，
新产生的值与RDD中下一个元素再被传递给输入函数直到最后只有一个值为止
val c = sc.parallelize(1 to 10)
c.reduce((x, y) => x + y)
res4: Int = 55

filter

filter的功能是对元素进行过滤filter(func)
val file=sc.textFile(“hdfs://192.168.192.137:9000/data/t2.txt”)
val test=file.filter(line=>line.contains(“1”))
test.collect()

distinct()

distinct()distinct将RDD中的元素进行去重操作
word1.distinct().collect()

subtract(otherDataset)

subtract(otherDataset)相当于进行集合的差操作，RDD 1去除RDD 1和RDD 2交集中的所有元素
word2.subtract(word1).collect()

sample

sample将RDD这个集合内的元素进行采样，获取所有元素的子集
是否有放回的抽样、 百分比、 随机种子SampledRDD（withReplacement，fraction，seed）
·withReplacement=true，表示有放回的抽样；
·withReplacement=false，表示无放回的抽样
word1.sample(true,0.5,9).collect()
word2.sample(false,0.3,9).collect()

takeSample

takeSample(withReplacement，样本个数，seed)函数按设定的采样个数进行采样，同时返回结果不再是RDD
相当于对采样后的数据进行Collect（）返回结果的集合为单机的数组
word1.takeSample(true,2,9)

cache()

cache()将RDD元素缓存到内存
word2.cache()

Key-Value型Transformation算子

val file=sc.textFile(“hdfs://192.168.192.137:9000/data/t1.csv”)
val wordcount=file.map(x=>(x.split(‘,’)(0),x.split(‘,’)(1))) #将string切割成key-value对
wordcount.collect
val wordcount=file.map(x=>(x.split(‘,’)(0),x.split(‘,’)(1))).map(x=>(x._1,x._2.toDouble))
val wordcount=file.map(x=>(x.split(‘,’)(0),x.split(‘,’)(1))).map(x=>(x._1,x._2.toInt))
wordcount.collect

mapValues(f)

mapValues(f)：针对（Key，Value）型数据中的Value进行Map操作，而不对Key进行处理
val file=sc.textFile(“hdfs://192.168.192.137:9000/data/t1.csv”)
val wordCount = file.flatMap(.split(‘,’)).reduceByKey(+_)
val a = sc.parallelize(List(“dog”, “tiger”, “lion”, “cat”, “panther”, ” eagle”), 2)
val b = a.map(x => (x.length, x))
b.mapValues(x=>x+”s”).collect
b.mapValues(“x” + _ + “x”).collect
Array[(Int, String)] = Array((3,dog), (5,tiger), (4,lion), (3,cat), (7,panther), (6,” eagle”))

flatMapValues

flatMapValues每个一元素的Value被输入函数映射为一系列的值
val a = sc.parallelize(List((1,2),(3,4),(3,6)))
val b = a.flatMapValues(x=>x.to(5))

reduceByKey

reduceByKey对元素为KV对的RDD中Key相同的元素的Value进行reduce
val a = sc.parallelize(List((1,2),(3,4),(3,6)))
a.reduceByKey((x,y) => x + y).collect
res7: Array[(Int, Int)] = Array((1,2), (3,10))

groupByKey

groupByKey：将元素通过函数生成相应的Key，数据就转化为Key-Value格式，之后将Key相同的元素分为一组。
groupByKey([numTasks])输出的并行程度可以传递一个可选的numtasks参数设置不同数量的任务
a.groupByKey().collect

join

join对每个key下的元素进行笛卡尔积操作，返回的结果再展平
val rdd1 = sc.parallelize(List((‘a’,1),(‘a’,2),(‘b’,3),(‘b’,4)))
val rdd2 = sc.parallelize(List((‘a’,5),(‘a’,6),(‘b’,7),(‘b’,8)))
val re=rdd1 join rdd2
re.collect
Array[(Char, (Int, Int))] = Array((a,(1,5)), (a,(1,6)), (a,(2,5)), (a,(2,6)), (b,(3,7)), (b,(3,8)), (b,(4,7)), (b,(4,8)))

val rdd1 = sc.parallelize(List((‘a’,1),(‘a’,2),(‘b’,3),(‘b’,4)))
val rdd2 = sc.parallelize(List((‘b’,7),(‘b’,8)))
val re=rdd1 join rdd2
re.collect
Array[(Char, (Int, Int))] = Array((b,(3,7)), (b,(3,8)), (b,(4,7)), (b,(4,8)))

val rdd1 = sc.parallelize(List((‘b’,3),(‘b’,4)))
val rdd2 = sc.parallelize(List((‘a’,5),(‘a’,6),(‘b’,7),(‘b’,8)))
val re=rdd1 join rdd2
re.collect
Array[(Char, (Int, Int))] = Array((b,(3,7)), (b,(3,8)), (b,(4,7)), (b,(4,8)))

foreach

foreach(func)对RDD中的每个元素都应用f函数操作，不返回RDD和Array，而是返回Uint
val a = sc.parallelize(List((1,2),(3,4),(3,6)))
a.foreach(println)

保存文件输出文件saveAsTextFile

saveAsTextFile(path)函数将数据输出，存储到HDFS的指定目录
a.saveAsTextFile(“hdfs://192.168.192.137:9000/data/output/”)
saveAsObjectFile(path) 使用java序列化一个简单的格式写的数据元素，然后可以sparkcontext objectfile()加载使用。
saveAsSequenceFile(path) 将分区中的每10个元素组成一个Array，然后将这个Array序列化写入HDFS为SequenceFile的格式

lookup

lookup对（Key，Value）型的RDD操作，返回指定Key对应的元素形成的顺序
val rdd1 = sc.parallelize(List((‘a’,1),(‘a’,2),(‘b’,3),(‘b’,4)))
rdd1.lookup(‘a’)
Seq[Int] = WrappedArray(1, 2)

count

count返回整个RDD的元素个数
val a = sc.parallelize(List((1,2),(3,4),(3,6)))
a.count

sortByKey

sortByKey按key升序排序sortByKey(true) 降序排序sortByKey(false)
val rdd1 = sc.parallelize(List((‘a’,1),(‘a’,2),(‘b’,3),(‘b’,4)))
a.sortByKey().collect
a.sortByKey(false).collect

val file=sc.textFile(“hdfs://192.168.192.137:9000/data/t1.csv”)
val wordcount=file.map(x=>(x.split(‘,’)(0),x.split(‘,’)(1))) #将string切割成key-value对
wordcount.collect
val wordcount = file.flatMap(.split(‘,’)).map((,1)).reduceByKey(+)
val wcsort = wordcount.map(x => (x._2,x._1)).sortByKey(false).map(x => (x._2,x._1)) 先把key-value颠倒后按value的值排序然后再交换key-value位置

top

top可返回最大的k个元素top(num：Int)
val a = sc.parallelize(List((1,2),(3,4),(3,6)))
val c = sc.parallelize(1 to 10)
a.map(x => x._1).top(1) key的最大值
a.map(x => x._2).top(1) value的最大值
c.top(2)

take

take返回最前的k个元素
c.take(2)

takeOrdered

takeOrdered返回最小的k个元素，并且在返回的数组中保持元素的顺序
val c = sc.parallelize(List(4,3,2,1))
c.takeOrdered(2)

类型转换

Array 转换成String
val arr = Array(1,3,4,5)
val str = arr.mkString(“,”)
String转换成Array
str.split(“,”).toArray