Spark之常用操作

-- 筛选
val rdd = sc.parallelize(List("ABC","BCD","DEF"))
val filtered = rdd.filter(_.contains("C"))
filtered.collect()
Result:
Array[String] = Array(ABC, BCD)
-- 相乘
val rdd=sc.parallelize(List(1,2,3,4,5))
val times2 = rdd.map(_*2)
times2.collect()
Result:
Array[Int] = Array(2, 4, 6, 8, 10)
-- 分割
val rdd=sc.parallelize(List("Spark is awesome","It is fun"))
val fm=rdd.flatMap(str=>str.split(" "))
fm.collect()
Result:
Array[String] = Array(Spark, is, awesome, It, is, fun)
-- 频数
val word1=fm.map(word=>(word,1))
val wrdCnt=word1.reduceByKey(_+_)
wrdCnt.collect()
Result:
Array[(String, Int)] = Array((is,2), (It,1), (awesome,1), (Spark,1), (fun,1))
-- 交换
val cntWrd = wrdCnt.map{case (word, count) => (count, word)}
cntWrd.groupByKey().collect()
Result:
Array[(Int, Iterable[String])] = Array((1,ArrayBuffer(It, awesome, Spark, fun)), (2,ArrayBuffer(is)))
-- 排重
fm.distinct().collect()
Result:
Array[String] = Array(is, It, awesome, Spark, fun)
-- 并集
val rdd1=sc.parallelize(List('A','B'))
val rdd2=sc.parallelize(List('B','C'))
rdd1.union(rdd2).collect()
-- 交集
rdd1.intersection(rdd2).collect()
-- 笛卡尔积
rdd1.cartesian(rdd2).collect()
-- 相减
rdd1.subtract(rdd2).collect()
-- 连接
val personFruit = sc.parallelize(Seq(("Andy", "Apple"), ("Bob", "Banana"), ("Charlie", "Cherry"), ("Andy","Apricot")))
val personSE = sc.parallelize(Seq(("Andy", "Google"), ("Bob", "Bing"), ("Charlie", "Yahoo"), ("Bob","AltaVista")))
personFruit.join(personSE).collect()
Result:
Array[(String, (String, String))] = Array((Andy,(Apple,Google)), (Andy,(Apricot,Google)), (Charlie,(Cherry,Yahoo)), (Bob,(Banana,Bing)), (Bob,(Banana,AltaVista)))
-- 计数
val rdd = sc.parallelize(list('A','B','c'))
rdd.count()
Result:
long = 3
-- 展示数组
val rdd = sc.parallelize(list('A','B','c'))
rdd.collect()
Result:
Array[char] = Array(A, B, c)
-- 求和
val rdd = sc.parallelize(list(1,2,3,4))
rdd.reduce(_+_)
Result:
Int = 10
-- 截取
val rdd = sc.parallelize(list(1,2,3,4))
rdd.take(2)
Result:
Array[Int] = Array(1, 2)
-- 分别格式化
val rdd = sc.parallelize(list(1,2,3,4))
rdd.foreach(x=>println("%s*10=%s".format(x,x*10))) Result:
1*10=10 4*10=40 3*10=30 2*10=20
val rdd = sc.parallelize(list(1,2,3,4))
-- 首项
rdd.first()
Result:
Int = 1
-- 另存为
val hamlet = sc.textFile("/users/akuntamukkala/temp/gutenburg.txt") 

-- 针对两个pair RDD的转化操作（rdd = {(1, 2), (3, 4), (3, 6)}  other = {(3, 9)}）

-- subtractByKey 删掉RDD 中键与other RDD 中的键相同的元素
rdd.subtractByKey(other) {(1, 2)}

-- join 对两个RDD 进行内连接
rdd.join(other) {(3, (4, 9)), (3,(6, 9))}

-- rightOuterJoin 对两个RDD 进行连接操作，确保第一个RDD 的键必须存在（右外连接）
rdd.rightOuterJoin(other) {(3,(Some(4),9)),(3,(Some(6),9))}

-- leftOuterJoin 对两个RDD 进行连接操作，确保第二个RDD 的键必须存在（左外连接）
rdd.leftOuterJoin(other) {(1,(2,None)), (3,(4,Some(9))), (3,(6,Some(9)))}

-- cogroup 将两个RDD 中拥有相同键的数据分组到一起
rdd.cogroup(other) {(1,([],[])), (3,([4, 6],[]))}

-- 返回RDD 中的所有元素
rdd.collect() {1, 2, 3, 3}

-- RDD 中的元素个数
rdd.count() 4

-- 各元素在RDD 中出现的次数
rdd.countByValue() {(1, 1),(2, 1),(3, 2)}

-- 从RDD 中返回num 个元素
rdd.take(2) {1, 2} top(num) 

-- 从RDD 中返回最前面的num个元素
rdd.top(2) {3, 3} 

-- 从RDD 中按照提供的顺序返回最前面的num 个元素
rdd.takeOrdered(2)(myOrdering) {3, 3} 

-- 从RDD 中返回任意一些元素
rdd.takeSample(false, 1) 

-- 并行整合RDD 中所有数据（例如sum）
rdd.reduce((x, y) => x + y) 9 

-- 和reduce() 一样， 但是需要提供初始值
rdd.fold(0)((x, y) => x + y) 9 

-- 和reduce() 相似， 但是通常返回不同类型的函数 
rdd.aggregate((0, 0)) 
((x, y) =>(x._1 + y, x._2 + 1), 
(x, y) =>(x._1 + y._1, x._2 + y._2)) 
(9,4) 
-- 对RDD 中的每个元素使用给定的函数
rdd.foreach(func)