Spark_RDD操作

一：戒骄戒躁，安心平气。
1：rdd.aggregateByKey(）()与rdd…foldByKey()()区别 当分区内操作相同时，只是一个简化版。
2：求平均值 次数相加 数量相加：zero必须为map
val newRdd: RDD[(String, (Int, Int))] = rdd.aggregateByKey((0, 0))(
(t, v) => (t._1 + v, t._2 + 1 ),
(t1, t2) => (t1._1 + t2._1, t1._2 + t2._2)
)
val avgRdd: RDD[(String, Int)] = newRdd.mapValues {
case (num, cnt) => {
num / cnt
}
}
//combineByKey
//1.结构转换
//2.分区内计算规则
//3.分区间计算规则
3. val combineRdd: RDD[(String, (Int, Int))] = rdd.combineByKey(v => (v, 1),
(t: (Int, Int), v) => (t._1 + v, t._2 + 1),
(t1: (Int, Int), t2: (Int, Int)) => (t1._1 + t2._1, t1._2 + t2._2)
)

rdd.reduceByKey(_+_)===========================================combineByKeyWithClassTag[V]((v: V) => v, func, func, partitioner)1.第一个值不参与计算2.分区内计算规则。3.分区间计算规则
rdd.aggregateByKey(0)(_+_,_+_)======combineByKeyWithClassTag[U]((v: V) => cleanedSeqOp(createZero(), v),cleanedSeqOp, combOp, partitioner)1. 初始值和第一个相同key的value值的处理逻辑2.分区内计算规则3.分区间计算规则 
  
rdd.foldByKey(0)(_+_)====combineByKeyWithClassTag[V]((v: V) => cleanedFunc(createZero(), v),cleanedFunc, cleanedFunc, partitioner)
 1. 初始值和第一个相同key的value值的处理逻辑2.分区内计算规则3.分区间计算规则 2===3
rdd.combineByKey(v=>v,(x:Int,y)=>x+y,(x:Int,y:Int)=>x+y)==1.形同Key的第一条数据处理2.分区内数据处理逻辑3.分区间数据处理逻辑
Join:
	val joinRdd: RDD[(String, (Int, Int))] = rdd1.join(rdd2)  //将按照key分成新的touple  容易形成笛卡尔乘积。 内连接。
	rdd1.leftOuterJoin(rdd2)
2.val cogroup: RDD[(String, (Iterable[Int], Iterable[Int]))] = rdd1.cogroup(rdd2)
	//cogroup: connect+group 分组连接
案例：求每个省份 每个广告被点击的Top3
	timestame            省份     城市      用户        广告
1516609143867 			6 			7			 64 			16
1516609143869 			9 			4 			 75 			18
1516609143869 			1 			7 			 87 			12
		一思路     1.不是所有数据都是需要的 只要自己需要的  （省份     广告）
						2.缺什么补什么       （省份  广告  count）
						3.
	
	package com.rdd.testrdd

import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
//case class Agent(Province:Int,advertising:Int)
object TopThree {
def main(args: Array[String]): Unit = {
val conf = new SparkConf().setMaster(“local[*]”).setAppName(“count”)
val sc = new SparkContext(conf)
val input: RDD[String] = sc.textFile(“in/agent.log”)
//1.将原始数据转换（（河南，大力神），1）
val mapRDD: RDD[((String, String), Int)] = input.map(
line => {
val datas = line.split(" ")
((datas(1), datas(4)), 1)
}
)
//新将数据按照（省份，广告）分组
val reduceRDD: RDD[((String, String), Int)] = mapRDD.reduceByKey(+)
//2.将转换后的数据进行转换结构（（河南，大力神），1）=>（（河南，大力神），sum）
val newRDD: RDD[(String, (String, Int))] = reduceRDD.map {
case ((prv, ad), sum) => {
(prv, (ad, sum))
}
}
val groupRDD: RDD[(String, Iterable[(String, Int)])] = newRDD.groupByKey()
val resultRDD: RDD[(String, List[(String, Int)])] = groupRDD.mapValues(
iter => {
iter.toList.sortBy(.2)(Ordering.Int.reverse).take(3)
}
)
resultRDD.collect().foreach(println)
sc.stop()
}
}
行动算子
1：collect 方法会将不同分区的数据按照分区顺序采集到的Driver内存中进行处理。形成数组。
2：count 拿到数据源中数据的个数
3：first 取出数据源中数据的第一个
4：take 取出几个
5.takeOrdered() 排序后取前几个。
6.rdd.aggregate(10)(+,+)
*与 rdd.aggregateByKey(0)(+,+)区别 一个触发计算 行动算子 另外初始值是否彩玉运算
7.rdd.fold(9)(+)
8.countByKey
9.rdd.countByValue()
10.rdd.countByKey() ==wordCount
11.
RDD血缘关系：
RDD不存数据 因此需要保存保留RDD的依赖关系

RDD依赖关系：1.OneToOneDependency=>NarrowDependency
2.ShuffleDependency
DAG:
RDD任务划分：
RDD任务切分中间分为Application,Job,Stage和Task
1.Application初始化一个SparkContext即生成
2.Job:一个Action算子会生成一个Job .可以有多个行动算子。
3.Stage:Stage=ShuffleDependeycy+1
4.Task:一个Stage阶段中，最后一个RDD的分区数就是一个task
RDD持久化 在合适位置
1：package com.rdd.testrdd

import org.apache.spark.rdd.RDD
import org.apache.spark.storage.StorageLevel
import org.apache.spark.{SparkConf, SparkContext}

object Persist {
def main(args: Array[String]): Unit = {
val conf: SparkConf = new SparkConf().setMaster(“local[*]”).setAppName(“wc”)
val sc = new SparkContext(conf)
val rdd: RDD[String] = sc.makeRDD(List(“hello scala”,“hello spark”))
val mapRDD: RDD[(String, Int)] = rdd.flatMap(.split(" ")).map((,1))
//mapRDD.cache()
mapRDD.persist(StorageLevel.MEMORY_AND_DISK_SER) //缓存
val reduceRDD: RDD[(String, Int)] = mapRDD.reduceByKey(+)
val groupRDD: RDD[(String, Iterable[Int])] = mapRDD.groupByKey()
groupRDD.foreach(println)
reduceRDD.foreach(println)
sc.stop()
}
}
三：检查点保存
sc.setCheckpointDir(“in2/”)
mapRDD.checkpoint()
1：cache 是将数据临时存储在内存中进行数据重用
mapRDD.persist(StorageLevel.MEMORY_AND_DISK_SER) 将数据放在磁盘
都是临时保存
2.CheckPoint()是永久保存