SparkRDD0904.1

SparkRDD操作：
输入算子
变换算子（转换算子）【shuffle | 非shuffle】
缓存算子
行动算子
Spark数据源： HDFS 、Mysql 、外部存储系统一般都可以当成数据源
一个spark程序向执行的话需要有action算子（stage–》task | job任务）

一、算子：

初始化：
    val conf = new SparkConf()
      .setAppName("test1")
      .setMaster("local[1]")
    val sc = new SparkContext(conf)
    mapRDD.foreach(println)
案例一：flatMap算子 （one ---> many）
	val list: List[String] = List("A,B,C,D")
	val listRDD: RDD[String] = sc.parallelize(list)
	//扁平化算子
	val flatMapRDD: RDD[String] = listRDD.flatMap(line=>line.split(","))
案例二： map算子 （one --> one）
    val list: Seq[Int] = 1 to 4
    val listRDD: RDD[Int] = sc.parallelize(list)
    val mapRDD: RDD[Int] = listRDD.map(e=>e*4)
案例三 ： filter 
		  对父RDD中每一个元素数据执行对应的func函数
		  如果func函数返回true,保留当前父RDD中的元素数据
		  如果为false，过滤掉当前数据
 var list: List[String] = List(...)
 val listRDD: RDD[String] = sc.parallelize(list)
 val filterRDD = listRDD.filter(e => {
      val strList: Array[String] = e.split(",")
      strList(3).equals("0") // true | false
    })
案例四：Sample算子
    val sc = new SparkContext(conf)
    val list: Seq[Int] = 1 to 100
    val listRDD: RDD[Int] = sc.parallelize(list)
    val sampleRDD: RDD[Int] = listRDD.sample(false,0.2,1)
//作用：抽样的算子、从父RDD抽取一定量的数据
//withReplacement ： true ：有放回抽样 | false 无放回抽样
// fraction : 样本空间大小 、抽样比例
 //seed : 抽样过程中随机数种子
// 补充说明： 抽样20% / 不一定完全就是20%,会在20%上下浮动
案例五： union 
    val listRDD1: RDD[Int]  = sc.parallelize(1 to 5)
    val listRDD2: RDD[Int]  = sc.parallelize(3 to 10)
    val unionRDD: RDD[Int] = listRDD1.union(listRDD2)
案例六 ： join 
内连接
 //      ------------------------   inner join -----------------------------------  //
 	val joinRDD: RDD[(String, (String, String))] = stuMapRDD.join(scoreMapRDD)
外链接
//  ------------------------------    left join --------------------------------------//
//左外连接 ： 右表的数据可能为空，所以用了Option
    val leftOuterJoinRDD: RDD[(String, (String, Option[String]))] = stuMapRDD.leftOuterJoin(scoreMapRDD)
//右外连接 ： 左表的数据可能为空，所以用了Option
    val rightOuterJoinRDD: RDD[(String, (Option[String], String))] = stuMapRDD.rightOuterJoin(scoreMapRDD)
 //----------------------------------  full join ---------------------------------------//
	val fullOuterJoinRDD: RDD[(String, (Option[String], Option[String]))] = stuMapRDD.fullOuterJoin(scoreMapRDD)
       
案例七 ： 小众方法[算子]
    val left: RDD[Int] =  sc.parallelize(List(1,2,3))
    val right: RDD[Int] = sc.parallelize(List(3,4,5))
    var intersectionRDD: RDD[Int] = left intersection right//交集
    var cartesianRDD: RDD[(Int, Int)] = left cartesian righ//笛卡尔集
案例八 ：groupByKey vs reduceByKey [父RDD的泛型一般都是Tuple]
//把key相同的数据拉取成一个集合 
	val groupByKeyRDD: RDD[(String, Iterable[String])] = mapRDD.groupByKey()
 对比ReduceByKey : 
//是把key相同的数据拉取到同一组，对外提供了对同组数据操作的接口
    val reduceByKeyRDD = mapRDD.reduceByKey((v1,v2)=>v1+v2)
案例九 ： Distinct 
//去重
    val listRDD: RDD[String] = sc.parallelize(list)
    listRDD.distinct().foreach(println)
案例九 ：调优算子（distinct / group by）[ 2个算子 ]（基础型内容）
aggregateByKey：（聚合）
	   def aggregateByKey[U: ClassTag]
			      (zeroValue: U)  // 初始值  shuffle写这部分起作用
			       (seqOp: (U, V) => U,  shuffle写这部分起作用  ,局部聚合
			         combOp: (U, U) => U) shuffle读这部分起作用  ,全局聚合
			       : RDD[(K, U)]
			        = self.withScope {
			  aggregateByKey(zeroValue, defaultPartitioner(self))(seqOp, combOp)
			   }
combineByKey：（结合）
    def combineByKey[C](
		    createCombiner: Int => Int, // 初识值
		    mergeValue: (C, V) => C, // 局部聚合
		    mergeCombiners: (C, C) => C): RDD[(K, C)] = self.withScope {
		    //全局聚合
		    combineByKeyWithClassTag(createCombiner, mergeValue, mergeCombiners)(null)
      }
案例十 ： Action算子
          foreach （迭代）
          collect （拉取数据）
          saveAsTextFile (持久化数据)	 
          count(统计RDD中有多少条数据)	
		  take(取前几个元素、默认没有排序)
		  takeOrdered(可以取前几个元素，有默认排序规则，首个元素排序、还可以指定排序规则)
		  saveAsObjectFile(把对象写到文本里)
		  saveAsTextFile（把处理好的结果【字符串】写到文本里）
		  countByKey(按照key分组，统计值)
		  reduce() 
		  count()

二、RDD持久化操作：

MEMORY_ONLY ：只持久化内存
MEMORY_ONLY_SER ：数据只持久化内存（数据序列化）
MEMORY_AND_DISK：尽量内存
MEMORY_AND_DISK_SER 【公司】优先内存---之后磁盘【序列化】
	内存序列化：减小内存占用
	磁盘序列化：加速程序和磁盘之间的读写速度
DISK_ONLY ：只是磁盘
MEMORY_ONLY_2 ：内存备份
MEMORY_AND_DISK_2 ：
OFF_HEAP ： 非堆  

三、Shared Variables （共享变量）

Broadcast Variables（广播变量）【面试题】
		在Spark里面作用： 
			优化join，使用非shullfe的方式能够完成join
		    优化内存（调优点）

案例：
   val broadcastVar = sc.broadcast(bs)
    listRDD.map(num=>num * broadcastVar.value).foreach(println)

Accumulators（计数器）

案例：
	val accum = sc.longAccumulator("My Accumulator")
	accum.add(1)

普通排序：sortByKey

     def sortByKey(ascending: Boolean = true, numPartitions: Int = self.partitions.length)
     ascending : 排序规则  true : 升序 、 false : 降序
     numPartitions ： 对几个分区进行排序
          数据集有2个分区、排序也是针对两个分区进行排序 、局部有序
           数据集有2个分区、排序numPartitions = 1 、全局有序
    val list = List(.... )
    val words: RDD[String] = sc.parallelize(list).flatMap(_.split(" "))
    val ret: RDD[(String, Int)] = words.map((_, 1)).reduceByKey(_+_)          
	ret.map{case(key,count)=>(count,key)}//按照count进行排序
      .sortByKey(false,1)
      .map{case(count,key)=>(key,count)}
      .foreach(println) 

高级排序 ：对value或者有多个排序条件那么用sortBy

def sortBy[K](
      f: (T) => K,
      ascending: Boolean = true,
      numPartitions: Int = this.partitions.length)
      (implicit ord: Ordering[K], ctag: ClassTag[K]): RDD[T] = withScope {
          this.keyBy[K](f)
      .sortByKey(ascending, numPartitions)
      .values
      }
------------------------------------------------------- 
    val list = List(...)
    val words = sc.parallelize(list).flatMap(_.split(" "))
    val ret: RDD[(String, Int)] = words.map((_, 1)).reduceByKey(_+_)
    val sortedRDD = ret.sortBy(t => t, false, 1)(
      new Ordering[(String, Int)](){
        override def compare(x: (String, Int), y: (String, Int)) = {
          var ret = x._2.compareTo(y._2) // 先按照value进行排序
          if(ret == 0) {
            ret = y._1.compareTo(x._1) // value相同的话，按照key进行排序
          }
          ret
        }
      },
      ClassTag.Object.asInstanceOf[ClassTag[(String, Int)]] //t => t   |  (String, Int)
    )