RDD实战

RDD操作：三种操作Transformation（算子）和action（得到结果）、controller（容错和性能优化的支持checkpoint和（Cache）persist）。
1、transformation是对已有的RDD创建新的RDD，操作是具有Lazy特性，也就是说在transformation对元素进行处理的时候，只是标记对元素继续处理，不会真正的执行，除非遇到了action或checkpoint时才会真正执行。
2、action会产生一个job，shuffle会产生新的stage。

使用collect，会将会分布在不同的节点上数据收集起来，collect之后Array就是一个元素，不过这个元素是Tuple(key,value)。

在集群上面运行，ReduceByKey（+,1）数字1 为并行度，会产生一个结果文件。
下面是以下几个函数的案例：
map()、filter()、flatMap()、groupByKey()、reduceBykey()、join()、cogroup()

package com.quell.sparkimport org.apache.spark.{SparkConf, SparkContext}object Transformation {  def main(args:Array[String]): Unit = {    val sc=sparkContext("Transformation")    mapTransformation(sc)    //map案例    filteredTransformation(sc)  //filter案例   faltmapTransformation(sc)   //flatMap案例    groupByKeyTransforamtion(sc)  //groupByKey案例   reduceBykeyTransformation(sc)  //reduceBykey案例     joinTransformation(sc)          //join案例      cogroupTransformation(sc)    sc.stop()    //停止SparkContext,销毁相关的Driver  }  def sparkContext(name:String)={    val conf = new SparkConf().setAppName("ggg").setMaster("local")    val sc = new SparkContext(conf) //创建SparkContent,第一个RDD创建的唯一入口，也是Driver的灵魂，也是通往集群的唯一通道    sc  }  def mapTransformation(sc:SparkContext): Unit ={    val nums=sc.parallelize(1 to 10)    //根据集合创建RDD    val mapped=nums.map(item => item*2) //map适用于任何元素，且对其作用的集合中的每一个元素循环遍历并调用其作为                                         // 参数的函数对每一个遍历的元素进行具体化操作    mapped.collect().foreach(println)  //收集计算结果并通过foreach循环打印  }  def filteredTransformation(sc:SparkContext): Unit ={    val nums=sc.parallelize(1 to 20)    val filtered=nums.filter(item => item%2==0)    filtered.collect().foreach(println)  //收集计算结果并通过foreach循环打印  }  def faltmapTransformation(sc:SparkContext): Unit ={    val bigData=Array("Scala Spark Java Hadoop","Java Tachyon")  //实例化字符串类型的Array    val bigDataString=sc.parallelize(bigData)         //创建以字符串为元素类型的ParallelCollectionRDD    val words=bigDataString.flatMap(line => line.split(" "))  //首先是通过传入的参数的函数来作用于RDD的每个字符串进行单词切分 合并成一个大的数据集Scala Spark Java Hadoop Java Tachyon    words.collect().foreach(println)  //收集计算结果并通过foreach循环打印  }  def groupByKeyTransforamtion(sc: SparkContext): Unit ={    val data=Array(Tuple2(100,"spark"),Tuple2(90,"Tachyon"),Tuple2(95,"scala"),Tuple2(90,"hadoop"),Tuple2(100,"java"))    val dataRDD=sc.parallelize(data)    val datas=dataRDD.groupByKey()   //对具有相同的键值分组    datas.collect().foreach(println)  //收集计算结果并通过foreach循环打印  }  def reduceBykeyTransformation(sc:SparkContext): Unit ={    val lines = sc.textFile("E:/test/test.txt",4) //读取本地文件，并设置为4个Partition    val words=lines.flatMap(line => line.split(" "))    //对每一行的字符串进行单词拆分，并把所有行的拆分结果通过flat合并成为一个大的单词集合    val pairs = words.map(word => (word,1))    //在单词拆分的基础上对每个单词实例计数为1    val wordCounts = pairs.reduceByKey(_+_)    //对相同的key,进行Value的累计（包括local和Reducer同时Reduce）    val wordsort=wordCounts.map(wd =>(wd._2,wd._1)).sortByKey(false).map(wd =>(wd._2,wd._1))    //对单词出现频率进行排序    wordCounts.foreach(wd => println(wd._1 + ":" + wd._2))    wordsort.foreach(wd => println(wd._1+":"+wd._2))  }  def joinTransformation(sc:SparkContext): Unit ={    val studentNames=Array(Tuple2(1,"Spark"), Tuple2(2,"Tachyon"), Tuple2(3,"Hadoop"))    val studentScores=Array(Tuple2(1,100), Tuple2(2,95), Tuple2(3,65),Tuple2(4,56))    val names=sc.parallelize(studentNames)    val scores=sc.parallelize(studentScores)    val student=names.join(scores)   //rightOuterJoin,leftOuterJoin    student.collect().foreach(println)  }  def cogroupTransformation(sc: SparkContext): Unit = {    val studentNames=Array(Tuple2(1,"Spark"), Tuple2(2,"Tachyon"), Tuple2(3,"Hadoop"))    val studentScores=Array(Tuple2(1,100), Tuple2(2,95), Tuple2(3,92),Tuple2(1,86),Tuple2(3,90),Tuple2(1,85))    val names=sc.parallelize(studentNames)    val scores=sc.parallelize(studentScores)    val student=names.cogroup(scores)    student.collect().foreach(item => println("ID:  "+item._1+"   Name:  "+item._2._1+"   Score:  "+item._2._2))  }}

学习于：
ＤＴ大数据梦工厂
新浪微博：www.weibo.com/ilovepains/
微信公众号：DT_Spark
博客：http://.blog.sina.com.cn/ilovepains
TEL:[phone]
Email:[e-mail]