Spark（二）-- SparkCore扩展 (二) -- RDD算子

RDD 中的算子从功能上分为两大类

Transformation(转换) 它会在一个已经存在的 RDD 上创建一个新的 RDD, 将旧的 RDD 的数据转换为另外一种形式后放入新的 RDD（笔记：转换算子的本质其实就是生成各种rdd,让rdd之间具有联系，只是生成rdd链条，执行到转换的时候并不会执行整个程序，而是在Action被调用的时候，程序才会执行）

Action(动作) 执行各个分区的计算任务, 将的到的结果返回到 Driver 中

RDD 中可以存放各种类型的数据, 那么对于不同类型的数据, RDD 又可以分为三类

针对基础类型(例如 String)处理的普通算子

针对 Key-Value 数据处理的 byKey 算子

针对数字类型数据处理的计算算子

特点

Spark 中所有的 Transformations 是 Lazy(惰性) 的, 它们不会立即执行获得结果. 相反, 它们只会记录在数据集上要应用的操作. 只有当需要返回结果给 Driver 时, 才会执行这些操作, 通过 DAGScheduler 和 TaskScheduler 分发到集群中运行, 这个特性叫做 惰性求值

默认情况下, 每一个 Action 运行的时候, 其所关联的所有 Transformation RDD 都会重新计算, 但是也可以使用 presist 方法将 RDD 持久化到磁盘或者内存中. 这个时候为了下次可以更快的访问, 会把数据保存到集群上.

2.1 Transformations 算子

2.1.1 map: `map(T ⇒ U)`

用法：

sc.parallelize(Seq(1, 2, 3))
  .map( num => num * 10 )
  .collect()

作用

把 RDD 中的数据一对一的转为另一种形式

签名

def map[U: ClassTag](f: T ⇒ U): RDD[U]

参数

f → Map 算子是 原RDD → 新RDD 的过程, 传入函数的参数是原 RDD 数据, 返回值是经过函数转换的新 RDD 的数据

注意点

Map 是一对一, 如果函数是 String → Array[String] 则新的 RDD 中每条数据就是一个数组

2.1.2 flatMap(T ⇒ List[U])

用法：

sc.parallelize(Seq("Hello lily", "Hello lucy", "Hello tim"))
  .flatMap( line => line.split(" ") )
  .collect()

作用

FlatMap 算子和 Map 算子类似, 但是 FlatMap 是一对多

调用

def flatMap[U: ClassTag](f: T ⇒ List[U]): RDD[U]

参数

f → 参数是原 RDD 数据, 返回值是经过函数转换的新 RDD 的数据, 需要注意的是返回值是一个集合, 集合中的数据会被展平后再放入新的 RDD

注意点

flatMap 其实是两个操作, 是 map + flatten, 也就是先转换, 后把转换而来的 List 展开
Spark 中并没有直接展平 RDD 中数组的算子, 可以使用 flatMap 做这件事

2.1.3 filter(T ⇒ Boolean)

用法：

  /**
    * filter可以过滤掉数据集中一部分元素
    * filter中接收的函数，参数是每一个元素，如果这个函数返回true,当前元素会被加入，
    * 如果这个函数返回flase,当前元素会被过滤.
    */
  @Test
  def filter():Unit = {
    //1.定义集合
    //2.过滤数据
    //3.收集结果
    sc.parallelize(Seq(1,2,3,4,5,6,7,8,9,10))
      .filter(item => item%2==0)
      .collect()
      .foreach(item => println(item))
  }
  //运行结果：2 4 6 8 10

作用

Filter 算子的主要作用是过滤掉不需要的内容

2.1.4 mapPartitions(List[T] ⇒ List[U])

用法：

  @Test
  def mapPartitions2(): Unit = {
    //1.数据生成
    //2.算子使用
    //3.获取结果
    sc.parallelize(Seq(1, 2, 3, 4, 5, 6), 2)
      .mapPartitions(iter => {
        //遍历iter其中每一条数据进行转换，转换完成以后，返回这个iter
        //iter 是scala中的集合类型
        iter.map(iter => iter*10)
      })
      .collect()
      .foreach(x => print(x + " "))
  }
  //运行结果：10 20 30 40 50 60

作用:

RDD[T] ⇒ RDD[U] 和 map 类似, 但是针对整个分区的数据转换

2.1.5 mapPartitionsWithIndex

用法：

  /**
    * mapPartitions 和 mapPartitionsWithIndex的区别是func中多了一个参数，是分区号
    */
  @Test
  def mapPartitionsWithIndex(): Unit={
    sc.parallelize(Seq(1,2,3,4,5,6),2)
      .mapPartitionsWithIndex((index,iter) =>{
        println("index: " + index )
        iter.foreach(item => println(item))
        iter
      })
      .collect()
  }
  //运行结果： index: 0 index: 1
  //4 5 1 6 2 3

作用：

和 mapPartitions 类似, 只是在函数中增加了分区的 Index

2.1.6 mapValues

用法：

  /**
    * mapValue 也是 map, 只不过map作用于整条数据, mapValue 作用于 Value
    */
  @Test
  def mapValues(): Unit = {
    sc.parallelize(Seq(("a", 1), ("b", 2), ("c", 3)))
      .mapValues( item => item * 10 )
      .collect()
      .foreach(println(_))
  }
  //运行结果：(a,10) (b,20) (c,30)

作用

MapValues 只能作用于 Key-Value 型数据, 和 Map 类似, 也是使用函数按照转换数据, 不同点是 MapValues 只转换 Key-Value 中的 Value

2.1.7 sample(withReplacement, fraction, seed)

用法：

  /**
    * 作用: 把大数据集变小, 尽可能的减少数据集规律的损失
    * withReplacement: 指定为True的情况下, 可能重复, 如果是Flase, 无重复
    */
  @Test
  def sample(): Unit = {
    //1.定义集合
    //2.过滤数据
    //3.收集结果
    val rdd1 = sc.parallelize(Seq(1,2,3,4,5,6,7,8,9,10))
    val rdd2 = rdd1.sample(false,0.6)
    val result = rdd2.collect()
    result.foreach(item => println(item))
  }
  //运行结果：1 5 6 7 8

作用

Sample 算子可以从一个数据集中抽样出来一部分, 常用作于减小数据集以保证运行速度, 并且尽可能少规律的损失

参数

Sample 接受第一个参数为`withReplacement`, 意为是否取样以后是否还放回原数据集供下次使用, 简单的说, 如果这个参数的值为 true, 则抽样出来的数据集中可能会有重复
Sample 接受第二个参数为`fraction`, 意为抽样的比例
Sample 接受第三个参数为`seed`, 随机数种子, 用于 Sample 内部随机生成下标, 一般不指定, 使用默认值

2.1.8 union(other)

用法：

  /**
    * 并集 可以重复的
    */
  @Test
  def union(): Unit={
    val rdd1 = sc.parallelize(Seq(1,2,3,4,5))
    val rdd2 = sc.parallelize(Seq(3,4,5,6,7))

    rdd1.union(rdd2)
      .collect()
      .foreach(println(_))
  }
  //运行结果：1,2,3,4,5,3,4,5,6,7

作用：

取并集

2.1.9 intersection(other)

用法：

  /**
    * 交集 3,4,5
    */
  @Test
  def intersection(): Unit={
    val rdd1 = sc.parallelize(Seq(1,2,3,4,5))
    val rdd2 = sc.parallelize(Seq(3,4,5,6,7))

    rdd1.intersection(rdd2)
      .collect()
      .foreach(println(_))
  }
  //运行结果：3,4,5

作用

Intersection 算子是一个集合操作, 用于求得左侧集合和右侧集合的交集, 换句话说, 就是左侧集合和右侧集合都有的元素, 并生成一个新的 RDD

2.1.10 subtract(other, numPartitions)

用法：

  /**
    * 差集 1,2
    */
  @Test
  def subtract(): Unit={
    val rdd1 = sc.parallelize(Seq(1,2,3,4,5))
    val rdd2 = sc.parallelize(Seq(3,4,5,6,7))

    rdd1.subtract(rdd2)
      .collect()
      .foreach(println(_))
  }
  //运行结果：1,2

作用：

(RDD[T], RDD[T]) ⇒ RDD[T] 差集, 可以设置分区数

2.1.11 distinct(numPartitions)

用法：

sc.parallelize(Seq(1, 1, 2, 2, 3))
  .distinct()
  .collect()

作用

Distinct 算子用于去重

注意点

Distinct 是一个需要 Shuffled 的操作
本质上 Distinct 就是一个 reductByKey, 把重复的合并为一个

2.1.12 reduceByKey((V, V) ⇒ V, numPartition)

用法：

sc.parallelize(Seq(("a", 1), ("a", 1), ("b", 1)))
  .reduceByKey( (curr, agg) => curr + agg )
  .collect()

作用

首先按照 Key 分组生成一个 Tuple, 然后针对每个组执行 reduce 算子

调用

def reduceByKey(func: (V, V) ⇒ V): RDD[(K, V)]

参数

func → 执行数据处理的函数, 传入两个参数, 一个是当前值, 一个是局部汇总, 这个函数需要有一个输出, 输出就是这个 Key 的汇总结果

注意点

ReduceByKey 只能作用于 Key-Value 型数据, Key-Value 型数据在当前语境中特指 Tuple2
ReduceByKey 是一个需要 Shuffled 的操作
和其它的 Shuffled 相比, ReduceByKey是高效的, 因为类似 MapReduce 的, 在 Map 端有一个 Cominer, 这样 I/O 的数据便会减少

2.1.13 groupByKey()

用法：

sc.parallelize(Seq(("a", 1), ("a", 1), ("b", 1)))
  .groupByKey()
  .collect()

作用

GroupByKey 算子的主要作用是按照 Key 分组, 和 ReduceByKey 有点类似, 但是 GroupByKey 并不求聚合, 只是列举 Key 对应的所有 Value

注意点

GroupByKey 是一个 Shuffled
GroupByKey 和 ReduceByKey 不同, 因为需要列举 Key 对应的所有数据, 所以无法在 Map 端做 Combine, 所以 GroupByKey 的性能并没有 ReduceByKey 好

2.1.14 combineByKey()

用法：

val rdd = sc.parallelize(Seq(
  ("zhangsan", 99.0),
  ("zhangsan", 96.0),
  ("lisi", 97.0),
  ("lisi", 98.0),
  ("zhangsan", 97.0))
)

val combineRdd = rdd.combineByKey(
  score => (score, 1),
  (scoreCount: (Double, Int),newScore) => (scoreCount._1 + newScore, scoreCount._2 + 1),
  (scoreCount1: (Double, Int), scoreCount2: (Double, Int)) =>
    (scoreCount1._1 + scoreCount2._1, scoreCount1._2 + scoreCount2._2)
)

val meanRdd = combineRdd.map(score => (score._1, score._2._1 / score._2._2))

meanRdd.collect()

作用

对数据集按照 Key 进行聚合

调用

combineByKey(createCombiner, mergeValue, mergeCombiners, [partitioner], [mapSideCombiner], [serializer])

参数

createCombiner 将 Value 进行初步转换
mergeValue 在每个分区把上一步转换的结果聚合
mergeCombiners 在所有分区上把每个分区的聚合结果聚合
partitioner 可选, 分区函数
mapSideCombiner 可选, 是否在 Map 端 Combine
serializer 序列化器

注意点

combineByKey 的要点就是三个函数的意义要理解
groupByKey, reduceByKey 的底层都是 combineByKey

2.1.15 aggregateByKey()

用法：

val rdd = sc.parallelize(Seq(("手机", 10.0), ("手机", 15.0), ("电脑", 20.0)))
val result = rdd.aggregateByKey(0.8)(
  seqOp = (zero, price) => price * zero,
  combOp = (curr, agg) => curr + agg
).collect()
println(result)

作用

聚合所有 Key 相同的 Value, 换句话说, 按照 Key 聚合 Value

调用

rdd.aggregateByKey(zeroValue)(seqOp, combOp)

参数

zeroValue 初始值
seqOp 转换每一个值的函数（作用于每一条数据）
comboOp 将转换过的值聚合的函数（把整体聚合，生成最终的结果）

注意点 * 为什么需要两个函数? aggregateByKey 运行将一个`RDD[(K, V)]聚合为`RDD[(K, U)], 如果要做到这件事的话, 就需要先对数据做一次转换, 将每条数据从`V`转为`U`, `seqOp`就是干这件事的 ** 当`seqOp`的事情结束以后, `comboOp`把其结果聚合

和 reduceByKey 的区别::
- aggregateByKey 最终聚合结果的类型和传入的初始值类型保持一致
- reduceByKey 在集合中选取第一个值作为初始值, 并且聚合过的数据类型不能改变

2.1.16 foldByKey(zeroValue)((V, V) ⇒ V)

用法:

sc.parallelize(Seq(("a", 1), ("a", 1), ("b", 1)))
  .foldByKey(zeroValue = 10)( (curr, agg) => curr + agg )
  .collect()

作用

和 ReduceByKey 是一样的, 都是按照 Key 做分组去求聚合, 但是 FoldByKey 的不同点在于可以指定初始值

调用

foldByKey(zeroValue)(func)

参数

zeroValue 初始值
func seqOp 和 combOp 相同, 都是这个参数

注意点

FoldByKey 是 AggregateByKey 的简化版本, seqOp 和 combOp 是同一个函数
FoldByKey 指定的初始值作用于每一个 Value

2.1.17 join(other, numPartitions)

作用：

val rdd1 = sc.parallelize(Seq(("a", 1), ("a", 2), ("b", 1)))
val rdd2 = sc.parallelize(Seq(("a", 10), ("a", 11), ("a", 12)))

rdd1.join(rdd2).collect()

作用

将两个 RDD 按照相同的 Key 进行连接

调用

join(other, [partitioner or numPartitions])

参数

other 其它 RDD
partitioner or numPartitions 可选, 可以通过传递分区函数或者分区数量来改变分区

注意点

Join 有点类似于 SQL 中的内连接, 只会再结果中包含能够连接到的 Key
Join 的结果是一个笛卡尔积形式, 例如`"a", 1), ("a", 2和"a", 10), ("a", 11的 Join 结果集是 `"a", 1, 10), ("a", 1, 11), ("a", 2, 10), ("a", 2, 11）

2.1.18 cogroup(other, numPartitions)

用法：

val rdd1 = sc.parallelize(Seq(("a", 1), ("a", 2), ("a", 5), ("b", 2), ("b", 6), ("c", 3), ("d", 2)))
val rdd2 = sc.parallelize(Seq(("a", 10), ("b", 1), ("d", 3)))
val rdd3 = sc.parallelize(Seq(("b", 10), ("a", 1)))

val result1 = rdd1.cogroup(rdd2).collect()
val result2 = rdd1.cogroup(rdd2, rdd3).collect()

/*
执行结果:
Array(
  (d,(CompactBuffer(2),CompactBuffer(3))),
  (a,(CompactBuffer(1, 2, 5),CompactBuffer(10))),
  (b,(CompactBuffer(2, 6),CompactBuffer(1))),
  (c,(CompactBuffer(3),CompactBuffer()))
)
 */
println(result1)

/*
执行结果:
Array(
  (d,(CompactBuffer(2),CompactBuffer(3),CompactBuffer())),
  (a,(CompactBuffer(1, 2, 5),CompactBuffer(10),CompactBuffer(1))),
  (b,(CompactBuffer(2, 6),CompactBuffer(1),Co...
 */
println(result2)

作用

多个 RDD 协同分组, 将多个 RDD 中 Key 相同的 Value 分组

调用

cogroup(rdd1, rdd2, rdd3, [partitioner or numPartitions])

参数

rdd… 最多可以传三个 RDD 进去, 加上调用者, 可以为四个 RDD 协同分组
partitioner or numPartitions 可选, 可以通过传递分区函数或者分区数来改变分区

注意点

对 RDD1, RDD2, RDD3 进行 cogroup, 结果中就一定会有三个 List, 如果没有 Value 则是空 List, 这一点类似于 SQL 的全连接, 返回所有结果, 即使没有关联上
CoGroup 是一个需要 Shuffled 的操作

2.1.19 cartesian(other)

(RDD[T], RDD[U]) ⇒ RDD[(T, U)] 生成两个 RDD 的笛卡尔积

2.1.20 sortBy(ascending, numPartitions)

用法：

val rdd1 = sc.parallelize(Seq(("a", 3), ("b", 2), ("c", 1)))
val sortByResult = rdd1.sortBy( item => item._2 ).collect()
val sortByKeyResult = rdd1.sortByKey().collect()

println(sortByResult)
println(sortByKeyResult)

作用

排序相关相关的算子有两个, 一个是`sortBy`, 另外一个是`sortByKey`

调用

sortBy(func, ascending, numPartitions)

参数

`func`通过这个函数返回要排序的字段
`ascending`是否升序
`numPartitions`分区数

注意点

普通的 RDD 没有`sortByKey`, 只有 Key-Value 的 RDD 才有
`sortBy`可以指定按照哪个字段来排序, `sortByKey`直接按照 Key 来排序

2.1.21 partitionBy(partitioner)

使用用传入的 partitioner 重新分区, 如果和当前分区函数相同, 则忽略操作

2.1.22 coalesce(numPartitions)

用法：减少分区数

val rdd = sc.parallelize(Seq(("a", 3), ("b", 2), ("c", 1)))
val oldNum = rdd.partitions.length

val coalesceRdd = rdd.coalesce(4, shuffle = true)
val coalesceNum = coalesceRdd.partitions.length

val repartitionRdd = rdd.repartition(4)
val repartitionNum = repartitionRdd.partitions.length

print(oldNum, coalesceNum, repartitionNum)

作用

一般涉及到分区操作的算子常见的有两个, repartitioin 和 coalesce, 两个算子都可以调大或者调小分区数量

调用

repartitioin(numPartitions)
coalesce(numPartitions, shuffle)

参数

numPartitions 新的分区数
shuffle 是否 shuffle, 如果新的分区数量比原分区数大, 必须 Shuffled, 否则重分区无效

注意点

repartition 和 coalesce 的不同就在于 coalesce 可以控制是否 Shuffle
repartition 是一个 Shuffled 操作

2.1.23 repartition(numPartitions)

重新分区

2.1.24 repartitionAndSortWithinPartitions

重新分区的同时升序排序, 在partitioner中排序, 比先重分区再排序要效率高, 建议使用在需要分区后再排序的场景使用

2.2 Action 算子

2.2.1 reduce( (T, T) ⇒ U )

用法：

val rdd = sc.parallelize(Seq(("手机", 10.0), ("手机", 15.0), ("电脑", 20.0)))
val result = rdd.reduce((curr, agg) => ("总价", curr._2 + agg._2))
println(result)

作用

对整个结果集规约, 最终生成一条数据, 是整个数据集的汇总

调用

reduce( (currValue[T], agg[T]) ⇒ T )

注意点

reduce 和 reduceByKey 是完全不同的, reduce 是一个 action, 并不是 Shuffled 操作
本质上 reduce 就是现在每个 partition 上求值, 最终把每个 partition 的结果再汇总

笔记

reduceByKey和reduce有什么区别？

1.reduce是一个Action算子，redueceByKey是一个转换算子

2.假设一个RDD里面有1万条数据，大部分key相同，有10个不同的key

rdd.reduceByKey生成10条数据

rdd.reduce生成1条结果

reduceByKey本质上是先按照Key分组，然后把每组聚合

reduce是针对于一整个数据集来进行聚合

3.reduceByKey是针对KV型数据来进行计算，reduce可以针对所有类型的数据进行计算

reduce算子是一个Shuffle操作吗？

*Shuffle操作分为mapper和reduce,mapper将数据放入paritioner的函数计算，求得分往哪一个reducer,再分到对应的reducer中（多对多）

*reduce操作并没有mapper和reducer，因为reduce算子会作用于RDD中的每一个分区，然后再分区上求得局部结果，最终汇总到Driver中求得最终结果（多对一）

RDD中有5大属性，Partitioner再Shuffe过程中使用

Partitioner只有KV型的RDD才有

2.2.2 collect()

以数组的形式返回数据集中所有元素

2.2.3 count()

返回元素个数

2.2.4 first()

返回第一个元素

2.2.5 take( N )

返回前 N 个元素

2.2.6 takeSample(withReplacement, fract)

类似于 sample, 区别在这是一个Action, 直接返回结果

2.2.7 fold(zeroValue)( (T, T) ⇒ U )

指定初始值和计算函数, 折叠聚合整个数据集

2.2.8 saveAsTextFile(path)

将结果存入 path 对应的文件中

2.2.9 saveAsSequenceFile(path)

将结果存入 path 对应的 Sequence 文件中

2.2.10 countByKey()

用法：

val rdd = sc.parallelize(Seq(("手机", 10.0), ("手机", 15.0), ("电脑", 20.0)))
val result = rdd.countByKey()
println(result)

作用

求得整个数据集中 Key 以及对应 Key 出现的次数

注意点

返回结果为 Map(key → count)
常在解决数据倾斜问题时使用, 查看倾斜的 Key

2.2.11 foreach( T ⇒ … )

遍历每一个元素

应用

val rdd = sc.parallelize(Seq(("手机", 10.0), ("手机", 15.0), ("电脑", 20.0)))
// 结果: Array((手机,10.0), (手机,15.0), (电脑,20.0))
println(rdd.collect())
// 结果: Array((手机,10.0), (手机,15.0))
println(rdd.take(2))
// 结果: (手机,10.0)
println(rdd.first())

2.3 转换算子和动作算子总结

RDD 的算子大部分都会生成一些专用的 RDD

map, flatMap, filter 等算子会生成 MapPartitionsRDD

coalesce, repartition 等算子会生成 CoalescedRDD

常见的 RDD 有两种类型

转换型的 RDD, Transformation

动作型的 RDD, Action

常见的 Transformation 类型的 RDD

map

flatMap

filter

groupBy

reduceByKey

常见的 Action 类型的 RDD

collect

countByKey

reduce

2.4 RDD 对不同类型数据的支持

目标

理解 RDD 对 Key-Value 类型的数据是有专门支持的

理解 RDD 对数字类型也有专门的支持

一般情况下 RDD 要处理的数据有三类

字符串

键值对

数字型

RDD 的算子设计对这三类不同的数据分别都有支持

对于以字符串为代表的基本数据类型是比较基础的一些的操作, 诸如 map, flatMap, filter 等基础的算子

对于键值对类型的数据, 有额外的支持, 诸如 reduceByKey, groupByKey 等 byKey 的算子

同样对于数字型的数据也有额外的支持, 诸如 max, min 等

RDD 对键值对数据的额外支持

键值型数据本质上就是一个二元元组, 键值对类型的 RDD 表示为 RDD[(K, V)]

RDD 对键值对的额外支持是通过隐式支持来完成的, 一个 RDD[(K, V)], 可以被隐式转换为一个 PairRDDFunctions 对象, 从而调用其中的方法.

既然对键值对的支持是通过 PairRDDFunctions 提供的, 那么从 PairRDDFunctions 中就可以看到这些支持有什么

类别算子

聚合操作

reduceByKey

foldByKey

combineByKey

分组操作

cogroup

groupByKey

连接操作

join

leftOuterJoin

rightOuterJoin

排序操作

sortBy

sortByKey

Action

countByKey

take

collect

类别	算子
聚合操作	`reduceByKey`
`foldByKey`
`combineByKey`
分组操作	`cogroup`
`groupByKey`
连接操作	`join`
`leftOuterJoin`
`rightOuterJoin`
排序操作	`sortBy`
`sortByKey`
Action	`countByKey`
`take`
`collect`

RDD 对数字型数据的额外支持

对于数字型数据的额外支持基本上都是 Action 操作, 而不是转换操作

算子含义

count

个数

mean

均值

sum

求和

max

最大值

min

最小值

variance

方差

sampleVariance

从采样中计算方差

stdev

标准差

sampleStdev

采样的标准差
val rdd = sc.parallelize(Seq(1, 2, 3))
// 结果: 3
println(rdd.max())

算子	含义
`count`	个数
`mean`	均值
`sum`	求和
`max`	最大值
`min`	最小值
`variance`	方差
`sampleVariance`	从采样中计算方差
`stdev`	标准差
`sampleStdev`	采样的标准差

2.5 阶段练习和总结

导读

1.通过本节, 希望大家能够理解 RDD 的一般使用步骤

import org.apache.commons.lang.StringUtils
import org.apache.spark.{SparkConf, SparkContext}
import org.junit.Test

class StagePractice {

  @Test
  def pmProcess(): Unit ={
    //1.创建sc对象
    val conf = new SparkConf().setMaster("local[6]").setAppName("stage_practice")
    val sc = new SparkContext(conf)

    //2.读取文件
    val source = sc.textFile("dataset/BeijingPM20100101_20151231_noheader.csv")

    //3.通过算子处理数据
    //  1.抽取数据 年 月 PM 返回结果：((年,月), PM)
    //  2.清洗,过滤掉空的字符串,过滤掉NA
    //  3.聚合
    //  4.排序
    val resultRDD = source.map( x => ((x.split(",")(1),x.split(",")(2)),x.split(",")(6)))
      .filter( x => StringUtils.isNotEmpty(x._2) && !x._2.equalsIgnoreCase("NA"))
      .map( x => (x._1,x._2.toInt))
      .reduceByKey( (curr,agg) => curr + agg)
      .sortBy( x => x._2, ascending = false)

    //4.获取结果
    resultRDD.take(10).foreach(x => println(x))

    //5.运行测试
    sc.stop()

  }
}

通过上述代码可以看到, 其实 RDD 的整体使用步骤如下

20190518105630

HelloWorld闯天涯

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spark（二）-- SparkCore扩展 (二) -- RDD算子

目录2.RDD算子2.1 Transformations 算子2.1.1 map: map(T ⇒ U)2.1.2 flatMap(T ⇒ List[U])2.1.3 filter(T ⇒ Boolean)2.1.4 mapPartitions(List[T] ⇒ List[U])2.1.5 mapPartitionsWithIndex2.1.6 mapValues...
复制链接

扫一扫