spark复习笔记(4):RDD变换
一、RDD变换
1.返回执行新的rdd的指针，在rdd之间创建依赖关系。每个rdd都有一个计算函数和指向父rdd的指针
Spark是惰性的，因此除非调用某个转换或动作，否则不会执行任何操作，否则将触发工作创建和执行。
2.map()是对每个元素进行变换，应用变换函数，返回的是一个新的分布式数据集，map就是对分区中的每个元素进行一个函数的调用，所以导致出现了那么多；
map() //对每个元素进行变换，应用变换函数，(T)=>V,
package com.jd.test import org.apache.spark.{SparkConf, SparkContext} object WordCountDemoScala1 { def main(args: Array[String]): Unit = { val conf = new SparkConf(); conf.setAppName("WordCountDemoScala1"); conf.setMaster("local"); val sc = new SparkContext(conf); val rdd1=sc.textFile("E:/studyFile/data/test.txt"); val rdd2 = rdd1.flatMap(line=>{ println("flatmap:"+line);line.split(" ")}) val rdd3 = rdd2.map((_,1)); val rdd4 = rdd3.reduceByKey(_ + _); val r = rdd4.collect(); r.foreach(println) } }
3.mapPartitions() //对RDD上的每个分区应用一个函数，返回一个新的RDD，输入的是一个迭代器，返回的是一个新的迭代器，可以对每个分区进行函数处理，而不是每个函数。现在是2个线程，四条数据，两条一切割
package com.jd.test
import org.apache.spark.{SparkConf, SparkContext}
object WordCountDemo3 {
def main(args: Array[String]): Unit = {
val conf = new SparkConf();
conf.setAppName("WordCountDemo3");
conf.setMaster("local[2]");//local[2]表示开启2个线程来模拟并发程序
val sc = new SparkContext(conf );
val rdd1 = sc.textFile("E:/studyFile/data/test.txt",2);//设置最小分区数为2
val rdd2 = rdd1.flatMap(_.split(" "));
val rdd3 = rdd2.mapPartitions(it=>{
import scala.collection.mutable.ArrayBuffer;
val buf = ArrayBuffer[String]();
val tname = Thread.currentThread().getName
println(tname+":"+"mapPartitions start");//将线程加入该分区
for (e<-it){
buf.+=("_"+e);
}
buf.iterator
});
val rdd4 = rdd3.map(word=>{
val tname=Thread.currentThread().getName
println(tname+":map"+word);
(word,1)})
val rdd5= rdd4.reduceByKey(_ + _);
rdd5.foreach(println)
}
}
下面演示并发线程数为4，最小分区数为4
package com.jd.test import org.apache.spark.{SparkConf, SparkContext} object WordCountDemo3 { def main(args: Array[String]): Unit = { val conf = new SparkConf(); conf.setAppName("WordCountDemo3"); conf.setMaster("local[4]");//local[4]表示并发线程数为4 val sc = new SparkContext(conf ); val rdd1 = sc.textFile("E:/studyFile/data/test.txt",4);//设置最小分区数为4 val rdd2 = rdd1.flatMap(_.split(" ")); val rdd3 = rdd2.mapPartitions(it=>{ import scala.collection.mutable.ArrayBuffer; val buf = ArrayBuffer[String](); val tname = Thread.currentThread().getName println(tname+":"+"mapPartitions start");//将线程加入该分区 for (e<-it){ buf.+=("_"+e); } buf.iterator }); val rdd4 = rdd3.map(word=>{ val tname=Thread.currentThread().getName println(tname+":map"+word); (word,1)}) val rdd5= rdd4.reduceByKey(_ + _); rdd5.foreach(println) } }
4.filter() //过滤器，(T)=>Boolean，返回一个唯一满足滤条件元素的RDD
5.flatMap() //压扁，T=>TraversableOnce[U]同上，(Int,Interator)=>Iterator<U>
6.sample(withReplacement,fraction,seed) //采样，返回采样的RDD子集。withReplacement元素是否可以多次采样，fraction:期望采样的数量[0,1]
package com.jd.test import org.apache.spark.{SparkConf, SparkContext} object SampleDemo { def main(args: Array[String]): Unit = { val conf = new SparkConf(); conf.setAppName("SampleDemo"); conf.setMaster("local"); val sc = new SparkContext(conf); val rdd1 = sc.textFile("E:/studyFile/data/test.txt"); val rdd2= rdd1.flatMap(_.split(" ")); val rdd3= rdd2.sample(false,0.5);//可以替换，被抽中的概率是0.5 rdd3.collect().foreach(println) } }
7.mapPartitionsWithIndex(func) //同上(int Iterator<T>)=Iterator<u>。与map函数相类似，但是也提供一个代表分区索引的整数的函数，所以当运行一个T类型的RDD的时候这个函数的类型必须是(Int,Iterator<T>)类型的，
8.union() //类似于mysql的union操作,返回一个新的数据集，其中包含元数据集和参数中 数据集的并集。
package com.jd.test import org.apache.spark.{SparkConf, SparkContext} object UnionDemo1 { def main(args: Array[String]): Unit = { val conf = new SparkConf(); conf.setMaster("local"); conf.setAppName("UnionDemo1") val sc = new SparkContext(conf); val rdd1 = sc.textFile("E:/studyFile/data/test.txt"); //所有hello行 val helloRDD=rdd1.filter(_.toLowerCase.contains("hello")); //所有world行 val worldRDD=rdd1.filter(_.toLowerCase.contains("world")); val allRDD=helloRDD.union(worldRDD); allRDD.collect().foreach(println) } }
//select * from persons where id<10 unoin select * from id persons where id>29
9.intersection //取出交集，提取两个rdd都含有的元素
package com.jd.test import org.apache.spark.{SparkConf, SparkContext} object IntersectionDemo1 { def main(args: Array[String]): Unit = { val conf = new SparkConf(); conf.setAppName("IntersectionDemo1"); conf.setMaster("local"); val sc = new SparkContext(conf); val rdd1 = sc.textFile("E:/studyFile/data/test.txt"); val rdd2 = rdd1.flatMap(_.split(" ")); val helloRDD = rdd2.filter(_.toLowerCase.contains("llo")); val worldRDD=rdd2.filter(_.toLowerCase.contains("wor")); val intersectRDD= helloRDD.intersection(worldRDD); intersectRDD.collect().foreach(println) } }
10.distinct([numTasks]) //去重操作
package com.jd.test import org.apache.spark.{SparkConf, SparkContext} object DistinctDemo{ def main(args: Array[String]): Unit = { val conf = new SparkConf(); conf.setMaster("local") conf.setAppName("DistinctDemo"); val sc = new SparkContext(conf); val rdd1 =sc.textFile("E:/studyFile/data/test.txt"); val rdd2 = rdd1.flatMap(_.split(" ")); val rdd3= rdd2.distinct() rdd3.collect().foreach(println) } }
11.reduceByKey(*) //按照key进行聚合
12.groupByKey() //按照key进行分组(K,V)=>(k,Iterable<V>)，当你在(K,V)对上调用这个函数的时候，结果会返回一个可以迭代的量(K,Iterable<V>),相同key值的数据别合在一起了。
package com.jd.test import org.apache.spark.{SparkConf, SparkContext} object GroupByKeyDemo { def main(args: Array[String]): Unit = { val conf = new SparkConf(); conf.setAppName("GroupByKeyDemo") conf.setMaster("local"); val sc = new SparkContext(conf); val rdd1 = sc.textFile("E:/codes/stus.txt"); val rdd2 = rdd1.map(line=>{ val key = line.split(" ")(3) (key,line); }); //通过key来进行分组 val rdd3 = rdd2.groupByKey(); rdd3.collect().foreach(t=>{ val key = t._1; println(key+":=================================================================>") for(e <- t._2){ println(e) } }) } }
13.reduceByKey(func,[numTasks])
当在(k,v)键值对上调用一个数据结集的时候，结果返回一个键值对，其中每个键对应的值都给定一个聚合函数func进行聚合，其类型必须是(V,V)=>V。同groupByKey一样，reduce的任务数通过第二个可选的参数进行指定
14.sortByKey([ascending],[numTasks]) //按key进行排序
15.join(otherDataset,[numTasks]) //横向连接，按key来进行联合，当你调用数据集(K,V)和(K,W)的时候，会返回一个新的数据集(K,(V,W))
16.cogroup协分组 //(K,V).cogroup(K,W)=>(K,(Iterable<V>,Iterator<W>))
package com.jd.test import org.apache.spark.{SparkConf, SparkContext} object CogroupDemp { def main(args: Array[String]): Unit = { val conf = new SparkConf(); conf.setAppName("CogroupDemp"); conf.setMaster("local[4]"); val sc = new SparkContext(conf); val rdd1 =sc.textFile("E:/codes/cogroup-1.txt") val rdd2 =rdd1.map(line=>{ val arr = line.split(" "); (arr(0),arr(1)); }); val rdd3 = sc.textFile("E:/codes/cogroup-2.txt"); val rdd4 = rdd3.map(line=>{ val arr = line.split(" "); (arr(0),arr(1)) }); val rdd = rdd2.cogroup(rdd4); rdd.collect().foreach(t=>{ println(t._1+":============================================>") for(e<-t._2._1){ println(e) } for (e<-t._2._2){ println(e) } }) } }
17.cartesian(otherDataset) //笛卡尔积，RR[T]=>RDD[(T,U)]。调用类型T和类型U的数据集，返回(T,U)所对的数据集
package com.jd.test import org.apache.spark.{SparkConf, SparkContext} //计算笛卡尔积 object cartesianDemo { def main(args: Array[String]): Unit = { val conf = new SparkConf(); conf.setMaster("local[4]"); conf.setAppName("cartesianDemo"); val sc = new SparkContext(conf); val rdd1 = sc.parallelize(Array("tom","jack","peter","stone","mike")); val rdd2 = sc.parallelize(Array("1234","2345","3456","5678")); val rdd3 = rdd1.cartesian(rdd2); rdd3.collect().foreach(t=>println(t)) } }
18.pipe //将rdd的元素传递给脚本或者命令
19.coalesce(numPartitions) //降低RDD中的分区数到指定的分区数
20.repartition //重新分区，分区数可增可减
package com.jd.test import org.apache.spark.{SparkConf, SparkContext} object SaveAsTextDemo { def main(args: Array[String]): Unit = { val conf = new SparkConf(); conf.setMaster("local"); conf.setAppName("SaveAsTextDemo"); val sc = new SparkContext(conf); val rdd1 = sc.textFile("E:/codes/test.txt"); val rdd2 = rdd1.flatMap(_.split(" ")); val rdd3 = rdd2.map((_,1)); //Merge the values for each key using an associative and commutative reduce function. This will // * also perform the merging locally on each mapper before sending results to a reducer, similarly // * to a "combiner" in MapReduce. val rdd4 = rdd3.reduceByKey(_ + _,3);//指定分区数为3，按key聚合，同时还指定分区数 rdd4.saveAsTextFile("E:/codes/out") } }
21.repartiotion //在RDD中重新进行shuffle操作，来随机的创建更多或者更少的分区，以及通过他们来进行分区的平衡，这经常用在网络间数据的shuffle
22.repartitionAndSortWithinPartitions(partitioner) //再分区并且排序
二、RDD Action
------------------------------------------------------------------
1.collect() //在客户端返回数据集的所有元素来作为数组，这在筛选器或其他操作返回足够小的数据子集之后非常有用。
2.reduce() //使用函数func(携带两个参数并返回一个参数)聚合数据集的元素，函数应该可以通信以及关联
3.count //返回数据集中RDD元素的个数，形成数组，手机RDD元素形成数组
4.first //只取第一个元素
5.take(n) //去除前n个元素
6.takeOrdered(n,[ordering]) //返回RDD的前n个元素，使用自然顺序或者用户比较器
7.saveAsTextFile(path) //保存到文件中去
8.saveAsSequenceFile(path) //保存成序列文件
9.countByKey() //按照key进行统计
三、Spark数据倾斜
数据倾斜问题，map阶段对key进行重新划分
