rdd基本操作

rdd基本操作

为该内容的学习记录。
https://blog.csdn.net/qq_41455420/article/details/79462653
这里是我自己的理解加上不懂得地方珈乐自己能理解的方式的解释，推荐看原作者。
代码片中，scala>开头的是输入的代码，res的为结果

1、spark启动

spark-shell

2、生成一个rdd

val a = sc.parallelize(1 to 9, 3)
# 创建一个a，内容是123456789，分成三个分区
#查看a：
	a.collect
#按分区查看a：
	a.glom().collect

3、map

scala> val a = sc.parallelize(1 to 9, 3)
scala> val b = a.map(x => x*2)
scala> a.collect
res10: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)
scala> b.collect
res11: Array[Int] = Array(2, 4, 6, 8, 10, 12, 14, 16, 18)

map是对RDD中的每个元素都执行一个指定的函数来产生一个新的RDD。 任何原RDD中的元素在新RDD中都有且只有一个元素与之对应。

3、filter

scala>val rdd = sc.parallelize(List(1,2,3,4,5,6))  
scala>val filterRdd = rdd.filter(_ > 5)
scala>filterRdd.collect() 
res11: Array[Int] = Array(6)

filter 是对RDD中的每个元素都执行一个指定的函数来过滤产生一个新的RDD。 任何原RDD中的元素在新RDD中都有且只有一个元素与之对应。（相当于select）

4、flatMap

举例：对原RDD中的每个元素x产生y个元素（从1到y，y为元素x的值）

scala> val a = sc.parallelize(1 to 4, 2)
scala> val b = a.flatMap(x => 1 to x)
scala> b.collect
res12: Array[Int] = Array(1, 1, 2, 1, 2, 3, 1, 2, 3, 4)
scala> b.glom().collect
res12: Array[Array[Int]] = Array(Array(1, 1, 2), Array(1, 2, 3, 1, 2, 3, 4))

与map类似，区别是原RDD中的元素经map处理后只能生成一个元素，而原RDD中的元素经flatmap处理后可生成多个元素来构建新RDD。

5、mapPartitions

scala> val a = sc.parallelize(1 to 9, 3)
scala> def myfunc[T](iter: Iterator[T]) : Iterator[(T, T)] = {
  var res = List[(T, T)]() 
  var pre = iter.next 
while (iter.hasNext) {
    val cur = iter.next
    res.::=(pre, cur)
      pre = cur  } 
  res.iterator
}
scala> a.mapPartitions(myfunc).collect
res0: Array[(Int, Int)] = Array((2,3), (1,2), (5,6), (4,5), (8,9), (7,8))

上述例子中的函数myfunc是把分区中一个元素和它的下一个元素组成一个Tuple。因为分区中最后一个元素没有下一个元素了，所以(3,4)和(6,7)不在结果中。
a的分区3个，分别是123、456、789，所以是12、23|45、56|78、89)
mapPartitions还有些变种，比如mapPartitionsWithContext，它能把处理过程中的一些状态信息传递给用户指定的输入函数。还有mapPartitionsWithIndex，它能把分区的index传递给用户指定的输入函数。

6、mapPartitionsWithIndex

var rdd1 = sc.makeRDD(1 to 5,2)
//rdd1有两个分区
var rdd2 = rdd1.mapPartitionsWithIndex{
        (x,iter) => {
          var result = List[String]()
          //如果有下一个元素，就加到i上，到没有为止，即功能为：将每个分区的元素累加。
            var i = 0
            while(iter.hasNext){
              i += iter.next()
            }
            result.::(x + "|" + i).iterator
        }
      }
//rdd2将rdd1中每个分区的数字累加，并在每个分区的累加结果前面加了分区索引
scala> rdd2.collect
res13: Array[String] = Array(0|3, 1|12)

def mapPartitionsWithIndex[U](f: (Int, Iterator[T]) => Iterator[U], preservesPartitioning: Boolean = false)(implicit arg0: ClassTag[U]): RDD[U]
函数作用同mapPartitions，不过提供了两个参数，第一个参数为分区的索引。

7、coalesce

scala> var data = sc.parallelize(1 to 12, 3) 
scala> data.collect 
scala> data.partitions.size 
scala> var rdd1 = data.coalesce(1) 
scala> rdd1.partitions.size 
scala> var rdd1 = data.coalesce(4) 
scala> rdd1.partitions.size
res2: Int = 1   //如果重分区的数目大于原来的分区数，那么必须指定shuffle参数为true，//否则，分区数不便
scala> var rdd1 = data.coalesce(4,true) 
scala> rdd1.partitions.size
res3: Int = 4