RDD的操作

RDD的创建

三种创建方式

• 从内存中创建

1. 使用parallelize

	val rdd = sc.parallelize(Array(1,2,3,4,5,6,7,8))

2. 使用makeRDD

	val rdd1 = sc.makeRDD(Array(1,2,3,4,5,6,7,8))

• 从外部存储创建（往后看）
• 由其他RDD转换（往后看）

传递给RDD的函数

运行在集群中的Spark API 强依赖于 driver 程序中给RDD传入的函数。官方推荐以下两种方式：

• 简短的匿名函数
• 伴生对象的静态方法

	object MyFunctions {
   
	  def func1(s: String): String = {
    ... }
	}
	
	myRdd.map(MyFunctions.func1)

除了使用静态方法以外，编码中也会出现传递一个实例方法的引用，但是这样会导致整个实例对象会被序列化发送到集群：

	//等同于rdd.map(x => this.func1(x))
	class MyClass {
   
	  def func1(s: String): String = {
    ... }
	  def doStuff(rdd: RDD[String]): RDD[String] = {
    rdd.map(func1) }
	}

如果抛序列化的异常，使类继承scala.Serializable即可。
访问类实例属性也有类似情况。

	//等同于rdd.map(x => this.field + x)
	class MyClass {
   
	  val field = "Hello"
	  def doStuff(rdd: RDD[String]): RDD[String] = {
    rdd.map(x => field + x) }
	}
	//为了避免这种情况可以这么做
	def doStuff(rdd: RDD[String]): RDD[String] = {
   
	  val field_ = this.field
	  rdd.map(x => field_ + x)
	}

理解闭包

理解Spark集群中执行的变量、方法的作用域和生命周期是个难点。
RDD 操作其作用域范围以外的变量常常会带来迷惑。
以下例子，就算运行在local模式同一JVM中，结果也跟想象不同：

	var counter = 0
	var rdd = sc.parallelize(data)
	// Wrong: Don't do this!!
	rdd.foreach(x => counter += x)
	println("Counter value: " + counter)

Job运行过程中，Spark将RDD操作分割成一个个Task，序列化后分发到Executor上执行。Executor执行的内容称作闭包。这个闭包中的变量、方法必须对Executor可见，比如上例foreach(）中涉及的部分。我们知道java对象经过序列化和反序列化以后，旧对象跟新对象是不一样的，所以Executor上的新闭包是一个副本，修改也是作用在副本上。所以上例打印的是0。

类似的情况，比如使用 rdd.foreach(println) or rdd.map(println)打印RDD的数据。在local模式单机上跑，Exexutor、Driver都在一个JVM中，可以在控制台上看到打印，但是在集群模式下，它是在Exexutor上打印，而不是在Driver端打印。要想在Driver上打印，需要使用collect()把整个RDD的数据抓取过来再打印，如果数据量大可能OOM，安全的做法是使用take()，比如rdd.take(100).foreach(println)

RDD转换算子

从操作对象上，分为value 类型和 key-value类型

value类型

map(func)
意义：将每一个输入元素经过func函数转换映射成新元素

	scala> var source = sc.parallelize(1 to 10)

	scala> val mapadd = source.map(_ * 2)
	
	scala> mapadd.collect()
	res8: Array[Int] = Array(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)

filter(func)
意义：过滤func函数计算后返回值为true的元素

	scala> var sourceFilter = sc.parallelize(Array("laozhang","laoli","woqu","daye"))
	
	scala> val filter = sourceFilter.filter(_.contains("lao"))
	
	scala> filter.collect()
	res5: Array[String] = Array(laozhang, laoli)

flatMap(func)
意义：将每一个输入元素经过func函数转换映射成新的0或多个元素（func返回一个Seq ）

	scala> val sourceFlat = sc.parallelize(1 to 5)

	scala> val flatMap = sourceFlat.flatMap(1 to _)
	
	scala> flatMap.collect()
	res22: Array[Int] = Array(1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 2, 3, 4, 5)

mapPartitions(func)
意义：以每一个分区为单位经func函数处理（func类型Iterator[T] => Iterator[U]）
跟map的区别：
map每次处理一条数据。mapPartition每次处理一个分区，每个分区处理完以前，数据不能回收，可能导致OOM，但是效率比map高。

	scala> val rdd = sc.parallelize(Array(1,2,3,4))

	scala> val mapRdd = rdd.mapPartitions(x=>x.map(_*2))
	
	scala> mapRdd .collect()
	res15: Array[Int] = Array(2, 4, 6, 8)

mapPartitionsWithIndex(func)
意义：以每一个分区为单位经func函数处理，多了一个分区号（func类型(Int, Interator[T]) => Iterator[U]）

	scala> val rdd = sc.parallelize(Array(1,2,3),2)

	scala> val indexRdd = rdd.mapPartitionsWithIndex((index,itr)=>(itr.map((index,_))))
	
	scala> indexRdd.collect(