Spark RDD常用算子使用总结

最新推荐文章于 2024-10-08 21:22:14 发布
最新推荐文章于 2024-10-08 21:22:14 发布
阅读量2.1k 收藏 13
点赞数
文章标签： spark SparkCore RDD
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shuyv/article/details/122226029
版权

文章目录

概述

对于 Spark 处理的大量数据而言，会将数据切分后放入RDD作为Spark 的基本数据结构，开发者可以在 RDD 上进行丰富的操作，之后 Spark 会根据操作调度集群资源进行计算。总结起来，RDD 的操作主要可以分为 Transformation 和 Action 两种。
在这里插入图片描述
官方文档

  • （1）Transformation 转换操作：返回一个新的RDD
    • which create a new dataset from an existing one
    • 所有Transformation函数都是Lazy，不会立即执行，需要Action函数触发
  • （2）Action动作操作：返回值不是RDD(无返回值或返回其他的)
    • which return a value to the driver program after running a computation on the datase
    • 所有Action函数立即执行（Eager），比如count、first、collect、take等
      在这里插入图片描述

此外注意RDD中函数细节：

  • 第一点：RDD不实际存储真正要计算的数据，而是记录了数据的位置在哪里，数据的转换关系(调用了什么方法，传入什么函数)；
  • 第二点：RDD中的所有转换都是惰性求值/延迟执行的，也就是说并不会直接计算。只有当发生一个要求返回结果给Driver的Action动作时，这些转换才会真正运行。之所以使用惰性求值/延迟执行，是因为这样可以在Action时对RDD操作形成DAG有向无环图进行Stage的划分和并行优化，这种设计让Spark更加有效率地运行

Transformation（转换算子）

在Spark中Transformation操作表示将一个RDD通过一系列操作变为另一个RDD的过程，这个操作可能是简单的加减操作，也可能是某个函数或某一系列函数。值得注意的是Transformation操作并不会触发真正的计算，只会建立RDD间的关系图。

如下图所示，RDD内部每个方框是一个分区。假设需要采样50%的数据，通过sample函数，从 V1、V2、U1、U2、U3、U4 采样出数据 V1、U1 和 U4，形成新的RDD。
在这里插入图片描述

1. map

源码：

def map[U](f : scala.Function1[T, U])(implicit evidence$3 : scala.reflect.ClassTag[U]) : org.apache.spark.rdd.RDD[U] = { /* compiled code */ }
  • 表示将 RDD 经由某一函数 f 后，转变为另一个RDD。

只需要传入一个函数即可，如下代码，将原来的Seq集合中每个元素都乘以10，再返回结果，如下：

  @Test
  def mapTest(): Unit = {
    // 1. 创建RDD
    val rdd1 = sc.parallelize(Seq(1, 2, 3))
    // 2. 执行 map 操作
    val rdd2 = rdd1.map(item => item * 10)
    // 3. 得到结果
    val result = rdd2.collect() //通过调用collect来返回一个数组，然后打印输出
    result.foreach(item => println(item))
  }

运行结果：

10
20
30

Process finished with exit code 0

2. flatMap

源码：

def flatMap[U](f : scala.Function1[T, scala.TraversableOnce[U]])(implicit evidence$4 : scala.reflect.ClassTag[U]) : org.apache.spark.rdd.RDD[U] = { /* compiled code */ }
  • 表示将 RDD 经由某一函数 f 后，转变为一个新的 RDD，但是与 map 不同，RDD 中的每一个元素会被映射成新的 0 到多个元素（f 函数返回的是一个序列 Seq）。

代码演示：

  @Test
  def flatMapTest() = {
    // 1. 创建RDD
    val rdd1 = sc.parallelize(Seq("Hello 吕布", "Hello 貂蝉", "Hello 铠"))
    // 2. 处理数据
    val rdd2 = rdd1.flatMap(item => item.split(" "))
    // 3. 查看结果
    val result = rdd2.collect()
    result.foreach(item => println(item))
    // 4. 关闭资源
    sc.stop()
  }

运行结果：

Hello
吕布
Hello
貂蝉
Hello
铠

Process finished with exit code 0

3. filter

源码：

def filter(f : scala.Function1[T, scala.Boolean]) : org.apache.spark.rdd.RDD[T] = { /* compiled code */ }
  • filter 可以过滤掉数据集中的一部分元素
  • filter 中接受的函数，参数是每一个元素，如果这个函数返回true，当前元素就会被加入新数据集，如果返回false，当前元素会被过滤掉

代码演示：

  @Test
  def filter() = {
    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

Process finished with exit code 0

4. mapPartitions

源码：

def mapPartitions[U](f : scala.Function1[scala.Iterator[T], scala.Iterator[U]], preservesPartitioning : scala.Boolean = { /* compiled code */ })(implicit evidence$6 : scala.reflect.ClassTag[U]) : org.apache.spark.rdd.RDD[U] = { /* compiled code */ }
  • mapPartitions 和 map算子一样，只不过map是针对每一条数据进行转换，mapPartitions针对一整个分区的数据进行转换
  • map的func参数是单条数据，mapPartitions的func参数是一个集合（一个分区所有的数据）
  • map的func返回值也是单条数据，mapPartitions的func返回值是一个集合

代码演示：

  @Test
  def mapPartitions(): Unit = {
    // 1. 数据生成
    // 2. 算子使用
    // 3. 获取结果
    sc.parallelize(Seq(1, 2, 3, 4, 5, 6), numSlices = 2)
      .mapPartitions(iter => {
        iter.foreach(item => println(item))
        iter
      })
      .collect()
  }

运行结果：

1
4
2
5
3
6

Process finished with exit code 0

如果想给上述集合中的元素都乘以10该，如何操作？

  @Test
  def mapPartitions2(): Unit = {
    // 1. 数据生成
    // 2. 算子使用
    // 3. 获取结果
    sc.parallelize(Seq(1, 2, 3, 4, 5, 6), numSlices = 2)
      .mapPartitions(iter => {
        // 如果想给集合中的数字都乘10，该如何操作？
        // 遍历 iter 其中每一条数据进行转换，转换完成之后，返回 iter
        val result = iter.map(item => item * 10)  //注意这个的map算子并不是RDD中的，而是Scala中的
        result
      })
      .collect()
      .foreach(item => println(item))
  }

运行结果：

10
20
30
40
50
60

Process finished with exit code 0

5. mapPartitionsWithIndex

源码：

def mapPartitionsWithIndex[U](f : scala.Function2[scala.Int, scala.Iterator[T], scala.Iterator[U]], preservesPartitioning : scala.Boolean = { /* compiled code */ })(implicit evidence$9 : scala.reflect.ClassTag[U]) : org.apache.spark.rdd.RDD[U] = { /* compiled code */ }
  • mapPartitionsWithIndex 和 mapPartitions 的区别是 func 参数中多了一个参数，分区号
  @Test
  def mapPartitionsWithIndex(): Unit = {
    sc.parallelize(Seq(1, 2, 3, 4, 5, 6), numSlices = 2)
      .mapPartitionsWithIndex( (index, iter) => {
        println("index: " + index)
        iter.foreach(item => println(item))
        iter
      } )
      .collect()
  }

运行结果：

index: 0
1
2
3
index: 1
4
5
6

Process finished with exit code 0

运行结果也有可能是这样：原因是RDD的并发性质

index: 1
index: 0
4
5
6
1
2
3

Process finished with exit code 0

6. sample

源码：

def sample(withReplacement : scala.Boolean, fraction : scala.Double, seed : scala.Long = { /* compiled code */ }) : org.apache.spark.rdd.RDD[T] = { /* compiled code */ }
  • 采样，尽可能减少数据集的规律损失
  • withReplacement 参数决定有放回或者无放回采样
  • fraction 参数是采样比例
  @Test
  def sample() = {
    val rdd1 = sc.parallelize(Seq(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))
    val rdd2 = rdd1.sample(false, 0.6)
    //第一个参数为false代表无放回采样，0.6是采样比例
    val result = rdd2.collect()
    result.foreach(item => println(item))
  }

运行结果：

3
4
5
6
7
8
9

Process finished with exit code 0

7. mapValues

源码：

def mapValues[U](f : scala.Function1[V, U]) : org.apache.spark.rdd.RDD[scala.Tuple2[K, U]] = { /* compiled code */ }
  • mapValues 也是 map，只不过map作用于整条数据，mapValues作用于 Value
  @Test
  def mapValues() = {
    sc.parallelize(Seq(("a", 1), ("b", 2), ("c", 3)))
      .mapValues(item => item * 10)
      .collect()
      .foreach(println(_))
  }

运行结果：

(a,10)
(b,20)
(c,30)

Process finished with exit code 0

8. union（并集）

  @Test
  def union() = {
    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

Process finished with exit code 0

9. substract（差集）

  @Test
  def subtract() = {
    val rdd1 = sc.parallelize(Seq(1, 2, 3, 4, 5))
    val rdd2 = sc.parallelize(Seq(3, 4, 5, 6, 7))

    rdd1.subtract(rdd2) //rdd1-rdd2
      .collect()
      .foreach(println(_))
  }

运行结果：

1
2

Process finished with exit code 0

10. reduceByKey

源码：

def reduceByKey(func : scala.Function2[V, V, V]) : org.apache.spark.rdd.RDD[scala.Tuple2[K, V]] = { /* compiled code */ }
  • 聚合操作时，往往聚合过程中需要中间临时变量（到底时几个变量，具体业务而定）
  @Test
  def reduceByKey() = {
    // 1.创建RDD
    val rdd1 = sc.parallelize(Seq("Hello 吕布", "Hello 貂蝉", "Hello 铠"))
    // 2.处理数据
    val rdd2 = rdd1.flatMap(item => item.split(" "))
      .map(item => (item, 1))
      .reduceByKey((curr, agg) => curr + agg) //注意agg是一个临时变量，或者局部结果，起始值为0
    // 3.得到结果
    val result = rdd2.collect()
    result.foreach(item => println(item))
    // 4.关闭资源
    sc.stop()

运行结果：

(铠,1)
(貂蝉,1)
(Hello,3)
(吕布,1)

Process finished with exit code 0

11. groupByKey

RDD中groupByKey和reduceByKey区别？？？

  • reduceByKey函数：在一个(K,V)的RDD上调用，返回一个(K,V)的RDD，使用指定的reduce函数，将相同key的值聚合到一起，reduce任务的个数可以通过第二个可选的参数来设置。简而言之，分组聚合。
    在这里插入图片描述
  • groupByKey函数：在一个(K,V)的RDD上调用，返回一个(K,V)的RDD，使用指定的函数，将相同key的值聚合到一起，与reduceByKey的区别是只生成一个sequence。简而言之就是只分组，不聚合。
    在这里插入图片描述
  @Test
  def groupByKey() = {
    sc.parallelize(Seq(("a", 1), ("a", 1), ("c", 3)))
      .groupByKey()
      .collect()
      .foreach(println(_))  //只有一个参数打印输出可以简写
  }

运行结果：

(a,CompactBuffer(1, 1))
(c,CompactBuffer(3))

Process finished with exit code 0

12. combineByKey

源码：

def combineByKey[C](
	createCombiner : scala.Function1[V, C], 
	mergeValue : scala.Function2[C, V, C], 
	mergeCombiners : scala.Function2[C, C, C]
) : org.apache.spark.rdd.RDD[scala.Tuple2[K, C]] = { /* compiled code */ }
  • CombineByKey 算子中接受三个参数：
    • 转换数据的函数（初始函数，作用于第一条数据，用于开启整个计算），在分区上进行聚合，把所有分区的聚合结果聚合为最终结果
  @Test
  def combineByKey() = {
    // 1.准备集合
    val rdd: RDD[(String, Double)] = sc.parallelize(Seq(
      ("铠", 100.0),
      ("耀", 99.0),
      ("镜", 99.0),
      ("镜", 98.0),
      ("铠", 97.0)
    ))
    // 2.算子操作
    //  2.1 createCombiner 转换数据
    //  2.2 mergeValue 分区上的聚合
    //  2.3 mergeCombiners 把分区上的结果再次聚合，生成最终结果
    val combineResult = rdd.combineByKey(
      createCombiner = (curr: Double) => (curr, 1),
      mergeValue = (curr: (Double, Int), nextValue: Double) => (curr._1 + nextValue, curr._2 + 1),
      mergeCombiners = (curr: (Double, Int), agg:(Double, Int)) => (curr._1 + agg._1, curr._2 + agg._2)
    )

    val resultRDD = combineResult.map( item => (item._1, item._2._1 / item._2._2))

    // 3. 输出数据
    resultRDD.collect().foreach(println(_))
  }

运行结果：

(铠,98.5)
(耀,99.0)
(镜,98.5)

Process finished with exit code 0

13. foldByKey

源码：

def foldByKey(zeroValue : V)(func : scala.Function2[V, V, V]) : org.apache.spark.rdd.RDD[scala.Tuple2[K, V]] = { /* compiled code */ }
  • foldByKey 和 reduceByKey 的区别是可以指定初始值
  • foldByKey 和 Scala中的 foldLeft、foldRight 区别是，这个初始值作用于每一个数据
  @Test
  def foldByKey() = {
    sc.parallelize(Seq(("a", 1), ("a", 1), ("b", 1)))
      .foldByKey(10)((curr, agg) => curr + agg)
      .collect()
      .foreach(println(_))
  }

运行结果：

(a,22)
(b,11)

Process finished with exit code 0

14. aggregateByKey

源码：

def aggregateByKey[U](zeroValue : U)(seqOp : scala.Function2[U, V, U], combOp : scala.Function2[U, U, U])(implicit evidence$3 : scala.reflect.ClassTag[U]) : org.apache.spark.rdd.RDD[scala.Tuple2[K, U]] = { /* compiled code */ }
  • aggregateByKey(zeroValue)(seqOp, combOp)
    • zeroValue：指定初始值
    • seqOp：作用于每个元素，根据初始值，进行计算
    • combOp：将 seqOp 处理过的结果进行聚合
  • aggregateByKey 比较适合针对每个数据要先处理，后聚合的场景
  @Test
  def aggregateByKey() = {
    val rdd = sc.parallelize(Seq(("手机", 10.0), ("手机", 15.0), ("电脑", 20.0)))
    rdd.aggregateByKey(0.8)((zeroValue, item) => item * zeroValue, (curr, agg) => curr + agg)
      .collect()
      .foreach(println(_))
  }

运行结果：

(手机,20.0)
(电脑,16.0)

Process finished with exit code 0

15. join

源码：

def join[W](
	other : org.apache.spark.rdd.RDD[scala.Tuple2[K, W]]
	) : org.apache.spark.rdd.RDD[scala.Tuple2[K, scala.Tuple2[V, W]]] = { /* compiled code */ }

在这里插入图片描述

  @Test
  def join() = {
    val rdd1 = sc.parallelize(Seq(("a", 1), ("a", 2), ("b", 1)))
    val rdd2 = sc.parallelize(Seq(("a", 10), ("a", 11), ("b", 12)))
    rdd1.join(rdd2)
      .collect()
      .foreach(println(_))
  }

运行结果：

(a,(1,10))
(a,(1,11))
(a,(2,10))
(a,(2,11))
(b,(1,12))

Process finished with exit code 0

16. sortBy

源码：

def sortBy[K](f : scala.Function1[T, K], ascending : scala.Boolean = { /* compiled code */ }, numPartitions : scala.Int = { /* compiled code */ })(implicit ord : scala.Ordering[K], ctag : scala.reflect.ClassTag[K]) : org.apache.spark.rdd.RDD[T] = { /* compiled code */ }
  • sortBy 可以用于任何类型数据的RDD，sortByKey 只有 KV 类型数据的RDD中才有
  • sortBy 可以按照任何部分顺序来排序，sortByKey 只能按照 Key 来排序
  • sortByKey 写发简单，不用编写函数了
  @Test
  def sort() = {
    val rdd1 = sc.parallelize(Seq(2, 4, 1, 5, 1, 8))
    val rdd2 = sc.parallelize(Seq(("a", 1), ("b", 3), ("c", 2)))

    println("-----------------------------")
    rdd1.sortBy(item => item).collect().foreach(println(_))
    println("-----------------------------")
    rdd2.sortBy(item => item._2).collect().foreach(println(_))
    println("-----------------------------")
    rdd2.sortByKey().collect().foreach(println(_))
  }

运行结果：

-----------------------------
1
1
2
4
5
8
-----------------------------
(a,1)
(c,2)
(b,3)
-----------------------------
(a,1)
(b,3)
(c,2)

Process finished with exit code 0

17. repartition

源码：

def repartition(numPartitions : scala.Int)(implicit ord : scala.Ordering[T] = { /* compiled code */ }) : org.apache.spark.rdd.RDD[T] = { /* compiled code */ }
  • repartition 进行重分区的时候，默认是 shuffle 的
  • coalesce 进行重分区的时候，默认是不 shuffle 的，coalesce 默认不能增大分区数
  @Test
  def partitioning() = {
    val rdd = sc.parallelize(Seq(1, 2, 3, 4, 5), 2)

    println(rdd.repartition(5).partitions.size)
    println(rdd.repartition(1).partitions.size)
    println(rdd.coalesce(5, shuffle = true ).partitions.size)
  }

}

5
1
5

Process finished with exit code 0

Action（执行算子）

不同于Transformation操作，Action操作代表一次计算的结束，不再产生新的 RDD，将结果返回到Driver程序或者输出到外部。所以Transformation操作只是建立计算关系，而Action 操作才是实际的执行者。每个Action操作都会调用SparkContext的runJob 方法向集群正式提交请求，所以每个Action操作对应一个Job。

1. reduce

源码：

def reduce(f : scala.Function2[T, T, T]) : T = { /* compiled code */ }
  • 函数中传入的 curr参数，并不是 Value，而是一整条数据
  • reduce 整体上的结果，只有一个
  • 聚合的时候，往往需要聚合 中间临时变量
  @Test
  def reduce() = {
    val rdd = sc.parallelize(Seq(("手机", 10.0), ("手机", 15.0), ("电脑", 20.0)))
    val result: (String, Double) = rdd.reduce((curr, agg) => ("总价", curr._2 + agg._2))
    println(result) // reduce的结果是一个元组
  }

运行结果：

(总价,45.0)

Process finished with exit code 0

2. foreach

源码：

def foreach(f : scala.Function1[T, scala.Unit]) : scala.Unit = { /* compiled code */ }
  • RDD中自带的foreach算子，注意输出的结果顺序不一定按照原来Seq集合中的顺序，是因为RDD是并行计算，异步操作。
  @Test
  def foreach() = {
    val rdd = sc.parallelize(Seq(1, 2, 3, 4))
    rdd.foreach(item => println(item))
  }

运行结果：

3
1
2
4

Process finished with exit code 0

3. count、countByKey、countByValue

  • count 和 countByKey 的结果相距很远，每次调用 Action 都会生成一个 job，job 会运行获取结果，所以在俩个 job中间有大量的 Log，其实就是在启动job
  • countByKey的运算结果是一个Map型数据：Map(a -> 2, b -> 1, c -> 1)
  • 数据倾斜：如果要解决数据倾斜，是不是要先知道谁倾斜，通过countByKey可以查看Key对应的数量，从而解决倾斜问题
  @Test
  def count() = {
    val rdd = sc.parallelize(Seq(("a", 1), ("b", 2), ("c", 3), ("a", 4)))
    println(rdd.count())  // 求出集合中数据的总数
    println(rdd.countByKey()) // 得出 Key
    println(rdd.countByValue())
  }

运行结果：

4
Map(a -> 2, b -> 1, c -> 1)
Map((b,2) -> 1, (c,3) -> 1, (a,1) -> 1, (a,4) -> 1)

Process finished with exit code 0

4. take、takeSample、first

  • take() 和 takeSample() 都是获取数据，一个是直接获取，一个是采样获取（又放回、无放回）
  • first：一般情况下，action 会从所有分区获取数据，相对来说速度比较慢，first 只是获取第一个元素所有只会处理第一个分区，所以速度很快，无需处理所有数据
  @Test
  def take() = {
    val rdd = sc.parallelize(Seq(1, 2, 3, 4, 5, 6))
    rdd.take(3).foreach(item => println(item))  // 返回前N个数据
    println(rdd.first())  // 返回第一个元素
    rdd.takeSample(withReplacement = false, num = 3).foreach(item => println(item))
  }

运行结果：

1
2
3
1
2
1
5

Process finished with exit code 0

5. max、min、mean、sum（数字运算）

  • 没有中位数，缺陷！
  @Test
  def numberic() = {
    val rdd = sc.parallelize(Seq(1, 2, 3, 4, 5, 10, 99, 120, 7))
    println(rdd.max())  // 最大值
    println(rdd.min())  // 最小值
    println(rdd.mean()) // 均值
    println(rdd.sum())  //求和
  }

运行结果：

120
1
27.888888888888893
251.0

Process finished with exit code 0

代码汇总

transformation 部分代码汇总

import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
import org.junit.Test

class TransformationOp {

  val conf: SparkConf = new SparkConf().setAppName("transformation_op").setMaster("local[6]")
  val sc = new SparkContext(conf)

  /*
    mapPartitions 和 map算子一样，只不过map是针对每一条数据进行转换，mapPartitions针对一整个
    分区的数据进行转换，所以：
      * 1. map的func参数是单条数据，mapPartitions的func参数是一个集合（一个分区所有的数据）
      * 2. map的func返回值也是单条数据，mapPartitions的func返回值是一个集合
   */


  @Test
  def mapPartitions(): Unit = {
    // 1. 数据生成
    // 2. 算子使用
    // 3. 获取结果
    sc.parallelize(Seq(1, 2, 3, 4, 5, 6), numSlices = 2)
      .mapPartitions(iter => {
        iter.foreach(item => println(item))
        iter
      })
      .collect()
  }


  @Test
  def mapPartitions2(): Unit = {
    // 1. 数据生成
    // 2. 算子使用
    // 3. 获取结果
    sc.parallelize(Seq(1, 2, 3, 4, 5, 6), numSlices = 2)
      .mapPartitions(iter => {
        // 如果想给集合中的数字都乘10，该如何操作？
        // 遍历 iter 其中每一条数据进行转换，转换完成之后，返回 iter
        val result = iter.map(item => item * 10)  //注意这个的map算子并不是RDD中的，而是Scala中的
        result
      })
      .collect()
      .foreach(item => println(item))
  }


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

  /*
    filter 可以过滤掉数据集中的一部分元素
    filter 中接受的函数，参数是每一个元素，如果这个函数返回true，当前元素就会被加入新数据集，
          如果返回false，当前元素会被过滤掉
   */
  @Test
  def filter() = {
    sc.parallelize(Seq(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))
      .filter(item => item % 2 == 0)  //取偶数
      .collect()
      .foreach(item => println(item))
  }

  /*
    sample 作用：采样，尽可能减少数据集的规律损失
   */
  @Test
  def sample() = {
    val rdd1 = sc.parallelize(Seq(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))
    val rdd2 = rdd1.sample(false, 0.6)
    //第一个参数为false代表无放回采样，0.6是采样比例
    val result = rdd2.collect()
    result.foreach(item => println(item))
  }

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

  /*
    交集
   */
  @Test
  def intersection() = {
    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(_))
  }

  /*
    并集
   */
  @Test
  def union() = {
    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(_))
  }

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

    rdd1.subtract(rdd2) //rdd1-rdd2
      .collect()
      .foreach(println(_))
  }

  /*
    只分组，不聚合
    groupByKey 运算结果格式：(Key, (value1, value2))
    reduceByKey 能不能在 Map 端做 Combiner：1.能不能减少IO
    groupByKey 在 Map端做 Combiner 没有意义
   */
  @Test
  def groupByKey() = {
    sc.parallelize(Seq(("a", 1), ("a", 1), ("c", 3)))
      .groupByKey()
      .collect()
      .foreach(println(_))  //只有一个参数打印输出可以简写
  }

  /*
    CombineByKey 算子中接受三个参数：
      转换数据的函数（初始函数，作用于第一条数据，用于开启整个计算），在分区上进行聚合，把所有分区的聚合结果聚合为最终结果

   */
  @Test
  def combineByKey() = {
    // 1.准备集合
    val rdd: RDD[(String, Double)] = sc.parallelize(Seq(
      ("铠", 100.0),
      ("耀", 99.0),
      ("镜", 99.0),
      ("镜", 98.0),
      ("铠", 97.0)
    ))
    // 2.算子操作
    //  2.1 createCombiner 转换数据
    //  2.2 mergeValue 分区上的聚合
    //  2.3 mergeCombiners 把分区上的结果再次聚合，生成最终结果
    val combineResult = rdd.combineByKey(
      createCombiner = (curr: Double) => (curr, 1),
      mergeValue = (curr: (Double, Int), nextValue: Double) => (curr._1 + nextValue, curr._2 + 1),
      mergeCombiners = (curr: (Double, Int), agg:(Double, Int)) => (curr._1 + agg._1, curr._2 + agg._2)
    )

    val resultRDD = combineResult.map( item => (item._1, item._2._1 / item._2._2))

    // 3. 输出数据
    resultRDD.collect().foreach(println(_))
  }

  /*
    foldByKey 和 reduceByKey 的区别是可以指定初始值
    foldByKey 和 Scala中的 foldLeft、foldRight 区别是，这个初始值作用于每一个数据
   */
  @Test
  def foldByKey() = {
    sc.parallelize(Seq(("a", 1), ("a", 1), ("b", 1)))
      .foldByKey(10)((curr, agg) => curr + agg)
      .collect()
      .foreach(println(_))
  }

  /*
    aggregateByKey(zeroValue)(seqOp, combOp)
      zeroValue：指定初始值
      seqOp：作用于每个元素，根据初始值，进行计算
      combOp：将 seqOp 处理过的结果进行聚合

    aggregateByKey 比较适合针对每个数据要先处理，后聚合的场景
   */
  @Test
  def aggregateByKey() = {
    val rdd = sc.parallelize(Seq(("手机", 10.0), ("手机", 15.0), ("电脑", 20.0)))
    rdd.aggregateByKey(0.8)((zeroValue, item) => item * zeroValue, (curr, agg) => curr + agg)
      .collect()
      .foreach(println(_))
  }

  @Test
  def join() = {
    val rdd1 = sc.parallelize(Seq(("a", 1), ("a", 2), ("b", 1)))
    val rdd2 = sc.parallelize(Seq(("a", 10), ("a", 11), ("b", 12)))
    rdd1.join(rdd2)
      .collect()
      .foreach(println(_))
  }


  /*
    sortBy 可以用于任何类型数据的RDD，sortByKey 只有 KV 类型数据的RDD中才有
    sortBy 可以按照任何部分顺序来排序，sortByKey 只能按照 Key 来排序
    sortByKey 写发简单，不用编写函数了
   */
  @Test
  def sort() = {
    val rdd1 = sc.parallelize(Seq(2, 4, 1, 5, 1, 8))
    val rdd2 = sc.parallelize(Seq(("a", 1), ("b", 3), ("c", 2)))

    println("-----------------------------")
    rdd1.sortBy(item => item).collect().foreach(println(_))
    println("-----------------------------")
    rdd2.sortBy(item => item._2).collect().foreach(println(_))
    println("-----------------------------")
    rdd2.sortByKey().collect().foreach(println(_))
  }


  /*
    repartition 进行重分区的时候，默认是 shuffle 的
    coalesce 进行重分区的时候，默认是不 shuffle 的，coalesce 默认不能增大分区数
   */
  @Test
  def partitioning() = {
    val rdd = sc.parallelize(Seq(1, 2, 3, 4, 5), 2)

    println(rdd.repartition(5).partitions.size)
    println(rdd.repartition(1).partitions.size)
    println(rdd.coalesce(5, shuffle = true ).partitions.size)
  }

}

action 部分代码汇总

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

class ActionOp {

  val conf = new SparkConf().setMaster("local[6]").setAppName("action_op")
  val sc = new SparkContext(conf)

  /*
    需求：最终生成 （结果， price）
    注意：
      1. 函数中传入的 curr参数，并不是 Value，而是一整条数据
      2. reduce 整体上的结果，只有一个
   */
  @Test
  def reduce() = {
    val rdd = sc.parallelize(Seq(("手机", 10.0), ("手机", 15.0), ("电脑", 20.0)))
    val result: (String, Double) = rdd.reduce((curr, agg) => ("总价", curr._2 + agg._2))
    println(result) // reduce的结果是一个元组
  }


  /*
    RDD中自带的foreach算子，注意输出的结果顺序不一定按照原来Seq集合中的顺序
    是因为RDD是并行计算，异步操作
   */
  @Test
  def foreach() = {
    val rdd = sc.parallelize(Seq(1, 2, 3, 4))
    rdd.foreach(item => println(item))
  }


  /*
    count 和 countByKey 的结果相距很远，每次调用 Action 都会生成一个 job，
    job 会运行获取结果，所以在俩个 job中间有大量的 Log，其实就是在启动job

    countByKey的运算结果是一个Map型数据：Map(a -> 2, b -> 1, c -> 1)

    数据倾斜：如果要解决数据倾斜，是不是要先知道谁倾斜，通过countByKey可以查看Key对应的
      数量，从而解决倾斜问题
   */
  @Test
  def count() = {
    val rdd = sc.parallelize(Seq(("a", 1), ("b", 2), ("c", 3), ("a", 4)))
    println(rdd.count())  // 求出集合中数据的总数
    println(rdd.countByKey()) // 得出 Key
    println(rdd.countByValue())
  }

  /*
    take() 和 takeSample() 都是获取数据，一个是直接获取，一个是采样获取（又放回、无放回）
    first：一般情况下，action 会从所有分区获取数据，相对来说速度比较慢，first 只是获取第一个元素
          所有只会处理第一个分区，所以速度很快，无需处理所有数据
   */
  @Test
  def take() = {
    val rdd = sc.parallelize(Seq(1, 2, 3, 4, 5, 6))
    rdd.take(3).foreach(item => println(item))  // 返回前N个数据
    println(rdd.first())  // 返回第一个元素
    rdd.takeSample(withReplacement = false, num = 3).foreach(item => println(item))
  }

  // 等等数字运算...   注意对于数字类型的支持，都是Action
  @Test
  def numberic() = {
    val rdd = sc.parallelize(Seq(1, 2, 3, 4, 5, 10, 99, 120, 7))
    println(rdd.max())  // 最大值
    println(rdd.min())  // 最小值
    println(rdd.mean()) // 均值
    println(rdd.sum())  //求和
  }

}
take off now
关注
spark RDD常用算子（三）
u010020897的博客
11-01 444
- first、take、collect、count、top、takeOrdered、foreach、fold、reduce、countByValue、lookup 算法解释 first：返回第一个元素 take：rdd.take(n)返回第n个元素 collect：rdd.collect() 返回 RDD 中的所有元素 count：rdd.count() 返回 RDD 中的元素个数 ...
spark RDD常用算子（一）
u010020897的博客
10-31 370
- filter 算法解释 filter 函数功能是对元素进行过滤，对每个 元 素 应 用 f 函 数， 返 回 值 为 true 的 元 素 在RDD 中保留，返回值为 false 的元素将被过滤掉。 内 部 实 现 相 当 于 生 成 FilteredRDD(this，sc.clean(f))。 源文件 过滤文件中的INFO日志 scala代码var rdd = sc.textFile...
Spark-RDD常用算子
曾哥的博客
04-10 805
算子的分类 spark的rdd的算子可以分为两大类：Transformation算子和 Action算子，其中Transformation算子是惰性的，只有rdd触发 Action算子时，才会执行Transformation算子；并且每个Transformation算子都会生成一个Task，每个Action算子都会生成一个job。 Transformation算子 parallelize：将...
Spark之RDD ,常用的触发算子大全
最新发布
qq_55006020的博客
10-08 976
Spark之RDD ,常用的触发算子大全, 输出算子,保存算子,常规聚合算子
大数据——Spark RDD常用算子总结
热门推荐
Vicky_Tang
07-28 1万+
Spark的核心是建立在同一的抽象弹性分布式数据集（Resilient Distributed Datasets，RDD）之上的，这使得Spark的各个组件可以无缝的进行集成，能够在同一个应用程序中完成大数据处理 1.RDD基本概念 RDD是spark提供的最重要的抽象概念，它是一种有容错机制的特殊数据集合，可以分布在集群的节点上，以函数式操作集合的方式进行各种并行操作 可以将RDD理解为一个分布式对象集合，本质上是一个只读的分区记录集合。每个RDD可以分成多个分区，每个分区就是一个数据集片段。一个R
大数据技术之Spark（二）——RDD常用算子介绍
five小点心的博客
03-31 3528
RDD 的操作分为和。就是从一个 RDD 产生一个新的 RDD；就是进行实际的计算。我们把RDD方法也称为算子。所以转换操作和行动操作一般也被叫做和。
Spark RDD 常用算子实例解析
我玩的很开心的博客
08-05 2056
Spark RDD 常用算子解析一、转换算子 Transformation（lazy）二、动作算子 Actions（non-lazy） 一、转换算子 Transformation（lazy） 二、动作算子 Actions（non-lazy） 对于转换操作，RDD的所有转换都不会直接计算结果。 Spark仅记录作用于RDD上的转换操作逻辑，当遇到动作算子（ Action）时才会进行真正计算。 RDD常见转换算子如下表： ...
Spark RDD常用算子
m0_47002117的博客
11-22 346
Spark RDD常用算子 一、parallelize 调用SparkContext 的 parallelize()，将一个存在的集合，变成一个RDD，这种方式试用于学习spark和做一些spark的测试 scala版本 scala的parallelize有两个参数，第一个是一个Seq集合，第二个是分区数，如果没有则会是默认分区数 scala版本可以选择makeRDD替换parallelize，java版本则没有 val rdd = sc.parallelize(List("A","B","C")) val
Spark RDD算子实战总结（超详细哦，绝对的干货！！！）
weixin_43520450的博客
09-10 4244
Spark RDD算子一、Spark算子概述二、Transformation算子下面来具体说明：三、Actions算子下面来具体说明：四、宽依赖和窄依赖 一、Spark算子概述 RDD：弹性分布式数据集，是一种特殊集合、支持多种来源、有容错机制、可以被缓存、支持并行操作，一个RDD代表多个分区里的数据集。 RDD有两种操作算子： Transformation（转换）：Transformation属于延迟计算，当一个RDD转换成另一个RDD时并没有立即进行转换，仅仅是记住了数据集的逻辑操作 Action
Spark 常用行动算子使用总结
web15870359587的博客
06-18 868
Spark RDD 中提供了丰富的 行动算子可以帮助我们完成对RDD数据的一些常用统计、聚合等业务的操作，下面将常用的行动算子进行使用总结；函数说明案例操作 代码中将列表中的数据进行两两聚合，运行代码，观察控制台输出效果函数签名函数说明案例操作 统计列表中元素个数，运行上面的代码，观察输出效果函数签名函数说明案例操作 运行程序，观察控制台输出结果函数签名函数说明案例操作 运行上面的程序，观察控制台输出效果函数签名函数说明案例操作 运行上面的程序，观察控制台输出函数签名函数说明案例展示 运行上面的程序，观察控
Spark的RDD转换算子与行动算子
Laoddaaa的博客
08-20 573
Spark的RDD转换算子与行动算子
SPARK RDD常用算子介绍
汝知否
11-19 364
常用的RDD转换操作API： 常用的RDD转换操作API 操作 含义 filter(func) 筛选出满足函数func的元素，并返回一个新的数据集 map(func) 将每个元素传递到函数func中，并将结果返回为一个新的数据集，一对一进行转换 flatmap(func) 与map()相似，但每个输入元素都可以映射到0或多个输出结果
Spark-RDD算子大全
YoungITの博客
01-16 937
Spark RDD（弹性分布式数据集）是Spark中的核心抽象，它代表一个不可变、分区的分布式数据集合。下面是一些常用的RDD算子：map(func)：对RDD中的每个元素应用给定的函数，返回一个新的RDD。filter(func)：对RDD中的每个元素应用给定的函数，返回满足条件的元素组成的新的RDD。flatMap(func)：对RDD中的每个元素应用给定的函数并返回一个迭代器，将所有迭代器的元素组合成一个新的RDD。
Spark-1-RDD常用算子
小羊的博客
11-30 519
目录 1、RDD简介 2、RDD创建 3、常用RDD算子 （1）Action RDD （2）单个RDD的 Transformation （惰性） （3）多个RDD的Transformation 1、RDD简介 Spark对数据的一种核心抽象，Resilient Distributed Dataset，弹性分布式数据集，不可变，是val类型 RDD数据存储在内存中，采购服务器...
Spark RDD算子总结
糊里糊涂走进大数据的小菜鸡
01-04 417
1、什么是RDD RDD（Resilient Distributed Dataset）叫做弹性分布式数据集，是 Spark 中最基本的数据处理模型。代码中是一个抽象类，它代表一个弹性的、不可变、可分区、里面的元素可并行计算的集合。 弹性 存储的弹性：内存与磁盘的自动切换； 容错的弹性：数据丢失可以自动恢复； 计算的弹性：计算出错重试机制； 分片的弹性：可根据需要重新分片。 分布式：数据存储在大数据集群不同节点上 数据集：RDD 封装了计算逻辑，并不保存数据 数据抽象：RDD 是一个抽象类，需要子类具体实现
Spark常用RDD算子总结
jiede1的博客
10-07 891
spark的算子比较多，但只有部分是常用的，特此记录下来，如需补充更多算子，请在评论留言。 常见RDD算子（非Key-Vaue型） map map作用在RDD分区的每一个元素上 scala> val nums=sc.parallelize(List(1,2,3)) nums: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[...
sparkRDD：第3节 RDD常用的算子操作
dengmanzhou3124的博客
08-29 499
4. RDD编程API 4.1 RDD的算子分类 Transformation（转换）：根据数据集创建一个新的数据集，计算后返回一个新RDD；例如：一个rdd进行map操作后生了一个新的rdd。 Action（动作）：对rdd结果计算后返回一个数值value给驱动程序，或者把结果存储到外部存储系统（例如HDFS）中； 例如：collect算子将数据集的所有...
Spark 系列（四）—— RDD常用算子详解
weixin_30385925的博客
08-09 328
一、Transformation spark 常用的 Transformation 算子如下表： Transformation 算子 Meaning（含义） map(func) 对原 RDD 中每个元素运用 func 函数，并生成新的 RDD filter(func) 对原 RDD 中每个元素使用func 函数进行过滤，并生成新的 RDD flatMap(func...
SparkRDD常用算子
太白_猿的博客
04-05 839
Spark的RDD常用算子
spark RDD常用算子
07-15
RDD算子调优是Spark性能调优的重要方面之一。以下是一些常见的RDD算子调优技巧： 1. 避免使用过多的shuffle操作，因为shuffle操作会导致数据的重新分区和网络传输，从而影响性能。 2. 尽量使用宽依赖操作（如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值