spark学习-rdd算子

有梦生

已于 2023-07-13 15:08:21 修改

阅读量242

点赞数

文章标签： spark 学习大数据

于 2023-07-13 11:31:10 首次发布

本文链接：https://blog.csdn.net/qq_52772669/article/details/131690536

版权

RDD是Spark的核心数据结构，是弹性分布式数据集的简称。文章详细介绍了RDD的创建方式以及各种算子的用法，包括Value类型的算子如map、flatMap、groupBy，以及key-value类型的算子如reduceByKey、join等，同时也提到了行动算子如reduce、collect。这些内容展示了RDD如何进行数据转换、过滤、聚合和分布计算。

摘要由CSDN通过智能技术生成

RDD是什么？

创建RDD的方法

Value类型的算子

1.map-把RDD内的数据逐条进行转换，可以是值的转换也可以是类型的转换

2.mapPartitions-把RDD内的数据以分区为单位放入可迭代对象，并且将处理后的数据也放入迭代对象中返回

3.mapPartitionsWithIndex:

4.flatMap:扁平化处理数据，我认为就是把rdd中可以迭代的数据类型中的数据都放到同一个可迭代对象中。

5.glom:把同一个分区的数据放到同一个数组内

6.groupBy:把数据根据指定的规则进行分组

7.filter()根据指定规则过滤出数据

8.sample:根据指定的规则从数据集中抽取数据

9.distinct:去除数据集中重复的元素,可以指定新生成的RDD的分区数

10.coalesce:用于合并分区减少分区的数量

11.repartition:可以增加或者减少分区数量

12.sortBy用于排序数据

双value类型

13.intersection：求两个RDD的数据交集

14.union：求两个RDD数据的并集

15.subtract：去除两个RDD的数据的重复部分，保留其他数据

16.zip

key-value类型

17.partitionBy

18.reduceByKey:按照相同的key对value进行聚合

19.groupByKey:将数据源的数据根据 key 对 value 进行分组

20.aggregateByKey:将数据根据不同的规则进行分区内计算和分区间计算

21.foldByKey:当aggregateByKey分区内和分区间操作相同时就是foldByKey

22.combineByKey:有3个参数，第一个参数表示value的格式，第二个参数表示相同key的value在分区内进行的操作，第三个参数表示相同key的value在分区间进行的操作

23.sortByKey:按照key对数据进行升序或者降序

24.join

25.leftOuterJoin:左外连接

26.cogroup

行动算子

1.reduce：先聚合分区内，再聚合分区间

2.collect:以数组形式返回RDD内的数据

3.count：返回RDD内的元素个数

4.first:返回RDD内的第一个元素

5.take:返回一个由前n个元素组成的数组

6.takeOrdered:返回RDD排序后的前n个元素

8.countByKey:统计每种key的个数

RDD是什么？

RDD（Resilient Distributed Dataset）叫做弹性分布式数据集，是 Spark 中最基本的数据处理模型，主要依靠算子相当于rdd的方法。

创建RDD的方法

1.从集合或者列表中获取数据创建算子，使用makeRDD()方法

 val rdd: RDD[Int] = sparkContext.makeRDD(List(1, 2, 3, 4));

2.从文件中获取数据创建RDD,使用textFile()方法

val rdd: RDD[String] = sparkContext.textFile("datas/1.txt");

Value类型的算子

1.map-把RDD内的数据逐条进行转换，可以是值的转换也可以是类型的转换

    //    从集合中获取数据
    val rdd: RDD[Int] = sparkContext.makeRDD(List(1, 2, 3, 4))
    //    使用map对数据进行转换,每个数据扩大2倍
    val rddmap: RDD[Int] = rdd.map(
      num => {
        num * 2
      }
    )

2.mapPartitions-把RDD内的数据以分区为单位放入可迭代对象，并且将处理后的数据也放入迭代对象中返回

    
    //    1.从集合中获取数据
    val rdd: RDD[Int] = sparkContext.makeRDD(List(1, 2, 3, 4),2)
    //    使用mapPartitions获取每个分区的最大值 mapPartitions内的匿名函数必须输入一个迭代器，返回一个迭代器
    val rddMapPartitions: RDD[Int] = rdd.mapPartitions(
      iter => {
        List(iter.max).iterator
      }
    )

3.mapPartitionsWithIndex:

函数定义：

def mapPartitionsWithIndex[U: ClassTag](
 f: (Int, Iterator[T]) => Iterator[U],
 preservesPartitioning: Boolean = false): RDD[U]

把数据以分区为单位进行处理，同时也能够获取分区索引，分区索引通常是从0开始

    //    1.从集合中获取数据
    val rdd: RDD[Int] = sparkContext.makeRDD(List(1, 2, 3, 4), 2)
    //    使用mapPartitionsWithIndex,获取第二个分区的数据
    val mpiRdd: RDD[Int] = rdd.mapPartitionsWithIndex(
      (index, datas) => {
        if (index == 1)
          {
            datas
          }
         else{
          Nil.toIterator
        }
      }
    )

4.flatMap:扁平化处理数据，我认为就是把rdd中可以迭代的数据类型中的数据或者可以再次切分的字符串切割后都放到同一个可迭代对象中。

    //    1.从集合中获取数据
    val rdd = sparkContext.makeRDD(List(List(1,2),List(3,4)))
//rdd内的数据类型要相同，否则的话会报错
val flatrdd: RDD[Int] = rdd.flatMap(
  line => {
    line
  }
)

如果list内包含不同数据类型，还需要使用模式匹配，变成相同的数据类型后再处理

    //    1.从集合中有List类型，又有整数类型
    val rdd = sparkContext.makeRDD(List(List(1,2),3,List(3,4)))
// flatmap对数据进行扁平化操作
val flatrdd: RDD[Any] = rdd.flatMap(
  data => {
    data match {
      case list: List[_] => list
      case dat => List(dat)
    }
  }
)

5.glom:把同一个分区的数据放到同一个数组内

    //    1.从集合中获取数据
    val rdd: RDD[Any] = sparkContext.makeRDD(List((1,2), "2", 3, 4), 2)
    //    使用glom把个体合并成整体，同一个分区的数据放到同一个数组内
   val glomrdd: RDD[Array[Any]] = rdd.glom()
    //    输出 如果直接println输出的是数组内的数组，而不是其中的数据
    glomrdd.collect().foreach(s=>{
      s.foreach(println)
    })
    println("========0号分区数据=========")
   println(glomrdd.collect()(0).mkString(","))
    println("========1号分区数据=========")
    println(glomrdd.collect()(1).mkString(","))

6.groupBy:把数据根据指定的规则进行分组

可以根据单词的首字母进行分组，返回数据的类型是：元组，元组内是分组依据和可迭代对象：（key,可迭代对象）

    //    1.从集合中获取数据
    val rdd = sparkContext.makeRDD(List("hello","world","spark","honest"))
//2.使用groupby把首字母相同的放入同一个分组中
val groupbyrdd: RDD[(Char, Iterable[String])] = rdd.groupBy(
  num => {
    num.charAt(0)
  }
)

7.filter()根据指定规则过滤出数据

过滤出list内的奇数

    //    1.从集合中获取数据
    val rdd: RDD[Int] = sparkContext.makeRDD(List(1, 2, 3, 4))
    val filterrdd: RDD[Int] = rdd.filter(
      nums => nums % 2 != 0
    )

8.sample:根据指定的规则从数据集中抽取数据

第一个参数boolean表示是否抽取元素是否放回，如果放回表示一个元素可能重复出现

第二个参数表示每个元素被抽取到的概率，范围是[ 0,1]

第三个参数表示随机种子数，输入一个正整数

实现原理：根据种子和随机算法算出一个数和第二个参数设置几率比较，小于第二个参数要，大于第二个参数则不要

    //    1.从集合中获取数据
    val rdd: RDD[Int] = sparkContext.makeRDD(List(1, 2, 3, 4))
    val samplerdd: RDD[Int] = rdd.sample(
      false, 0.5
    )

9.distinct:去除数据集中重复的元素,可以指定新生成的RDD的分区数

val distinctRDD = originalRDD.distinct([numPartitions])

numPartitions用于指定分区数

10.coalesce:用于合并分区减少分区的数量

val conf = new SparkConf().setAppName("CoalesceExample").setMaster("local")
val sc = new SparkContext(conf)

val data = sc.parallelize(1 to 10, 5) // 创建5个分区的RDD
val coalescedData = data.coalesce(2) // 合并成两个分区

11.repartition:可以增加或者减少分区数量

def repartition(numPartitions: Int)(implicit ord: Ordering[T] = null): RDD[T]

12.sortBy用于排序数据

val sortedRDD = originalRDD.sortBy(func, ascending = true, numPartitions)

// func用于指定排序的依据
//ascending如果指定为true的话就是升序，false是降序
//numPartitions用来指定排序后的RDD数量，不写的话默认是原有RDD的分区数

双value类型

13.intersection：求两个RDD的数据交集

val dataRDD1 = sparkContext.makeRDD(List(1,2,3,4))
val dataRDD2 = sparkContext.makeRDD(List(3,4,5,6))
val dataRDD = dataRDD1.intersection(dataRDD2)

14.union：求两个RDD数据的并集

val dataRDD1 = sparkContext.makeRDD(List(1,2,3,4))
val dataRDD2 = sparkContext.makeRDD(List(3,4,5,6))
val dataRDD = dataRDD1.union(dataRDD2)

15.subtract：去除两个RDD的数据的重复部分，保留其他数据

val dataRDD1 = sparkContext.makeRDD(List(1,2,3,4))
val dataRDD2 = sparkContext.makeRDD(List(3,4,5,6))
val dataRDD = dataRDD1.subtract(dataRDD2)

16.zip

将两个 RDD 中的元素，以键值对的形式进行合并。其中，键值对中的 Key 为第 1 个 RDD 中的元素，Value 为第 2 个 RDD 中的相同位置的元素。

val dataRDD1 = sparkContext.makeRDD(List(1,2,3,4))
val dataRDD2 = sparkContext.makeRDD(List(3,4,5,6))
val dataRDD = dataRDD1.zip(dataRDD2)

key-value类型

17.partitionBy

将数据按照指定 Partitioner 重新进行分区。Spark 默认的分区器是 HashPartitioner(分区数量)

    val rdd = sparkContext.makeRDD(List((1,1),(2,1),(3,1),(4,1)),2)
rdd.partitionBy(new HashPartitioner(2))

HashPartitioner是根据key的哈希码与分区数进行取余，根据取余的结果来对数据进行分区。

返回数据类型是一个元组.

18.reduceByKey:按照相同的key对value进行聚合

def reduceByKey(func: (V, V) => V, numPartitions: Int): RDD[(K, V)]

可以指定聚合后的分区数量，默认是原RDD的分区数，返回值类型是元组

19.groupByKey:将数据源的数据根据 key 对 value 进行分组

val dataRDD1 =
 sparkContext.makeRDD(List(("a",1),("b",2),("c",3)))
val dataRDD2 = dataRDD1.groupByKey()
//指定分区数量是2
val dataRDD3 = dataRDD1.groupByKey(2)
//指定分区规则
val dataRDD4 = dataRDD1.groupByKey(new HashPartitioner(2))

20.aggregateByKey:将数据根据不同的规则进行分区内计算和分区间计算

val dataRDD1 =
 sparkContext.makeRDD(List(("a",1),("b",2),("c",3)))
val dataRDD2 =
 dataRDD1.aggregateByKey(0)(_+_,_*_)

第一个括号内表示的是初始值（初始值决定了返回的数据类型），第二个括号内第一个参数表示分区内进行的操作，第二个参数表示分区间进行的操作，分区内和分区间的操作可以相同也可以不同。

21.foldByKey:当aggregateByKey分区内和分区间操作相同时就是foldByKey

val dataRDD1 = sparkContext.makeRDD(List(("a",1),("b",2),("c",3)))
val dataRDD2 = dataRDD1.foldByKey(0)(_+_)

22.combineByKey:有3个参数，第一个参数表示value的格式，第二个参数表示相同key的value在分区内进行的操作，第三个参数表示相同key的value在分区间进行的操作

    //    1.从集合中获取数据，求每个k对应数据的平均值
    val rdd: RDD[(String, Int)] = sparkContext.makeRDD(List(("a", 1), ("a"  , 2), ("b", 3), ("b", 4), ("b", 5), ("a", 6)))
    val combinrdd: RDD[(String, (Int, Int))] = rdd.combineByKey(
//   v代表原始RDD内的value,1代表出现的次数
      v => (v, 1),
//   分区内进行 操作
      (t: (Int, Int), v) => {
 //    (相同key的value值相加，记录出现次数)
        (t._1 + v, t._2 + 1)
      }
      ,
      (t1: (Int, Int), t2: (Int, Int)) => {
        (t1._1 + t2._1, t1._2 + t2._2)
      }
    )

23.sortByKey:按照key对数据进行升序或者降序

def sortByKey(ascending: Boolean = true, numPartitions: Int = self.partitions.length)
 : RDD[(K, V)]

val dataRDD1 = sparkContext.makeRDD(List(("a",1),("b",2),("c",3)))
val sortRDD1: RDD[(String, Int)] = dataRDD1.sortByKey(true)
val sortRDD1: RDD[(String, Int)] = dataRDD1.sortByKey(false)

24.join

在类型为(K,V)和(K,W)的 RDD 上调用，返回一个相同 key 对应的所有元素连接在一起的 (K,(V,W))的 RDD

val rdd: RDD[(Int, String)] = sc.makeRDD(Array((1, "a"), (2, "b"), (3, "c")))
val rdd1: RDD[(Int, Int)] = sc.makeRDD(Array((1, 4), (2, 5), (3, 6)))
rdd.join(rdd1).collect().foreach(println)

25.leftOuterJoin:左外连接

val dataRDD1 = sparkContext.makeRDD(List(("a",1),("b",2),("c",3)))
val dataRDD2 = sparkContext.makeRDD(List(("a",1),("b",2),("c",3)))
val rdd: RDD[(String, (Int, Option[Int]))] = dataRDD1.leftOuterJoin(dataRDD2)

26.cogroup

在类型为(K,V)和(K,W)的 RDD 上调用，返回一个(K,(Iterable,Iterable))类型的 RDD

val dataRDD1 = sparkContext.makeRDD(List(("a",1),("a",2),("c",3)))
val dataRDD2 = sparkContext.makeRDD(List(("a",1),("c",2),("c",3)))
val value: RDD[(String, (Iterable[Int], Iterable[Int]))] = 
dataRDD1.cogroup(dataRDD2)

行动算子

1.reduce：先聚合分区内，再聚合分区间

val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4)) // 聚合数据 
val reduceResult: Int = rdd.reduce(_+_)

2.collect:以数组形式返回RDD内的数据

val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4))
// 收集数据到 Driver
rdd.collect().foreach(println)

3.count：返回RDD内的元素个数

val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4))
// 返回 RDD 中元素的个数
val countResult: Long = rdd.count()

4.first:返回RDD内的第一个元素

val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4))
// 返回 RDD 中元素的个数
val firstResult: Int = rdd.first()
println(firstResult)

5.take:返回一个由前n个元素组成的数组

vval rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4))
// 返回 RDD 中元素的个数
val takeResult: Array[Int] = rdd.take(2)
println(takeResult.mkString(","))

6.takeOrdered:返回RDD排序后的前n个元素

val rdd: RDD[Int] = sc.makeRDD(List(1,3,2,4))
// 返回 RDD 中元素的个数，默认是升序
val result: Array[Int] = rdd.takeOrdered(2)
//降序
val ints1= rdd.takeOrdered(3)(Ordering[Int].reverse)

7.aggregate:分区的数据通过初始值和分区内的数据进行聚合，然后再和初始值进行分区间的数据聚合

val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4), 8)
// 将该 RDD 所有元素相加得到结果
//val result: Int = rdd.aggregate(0)(_ + _, _ + _)
val result: Int = rdd.aggregate(10)(_ + _, _ + _)

8.countByKey:统计每种key的个数

val rdd: RDD[(Int, String)] = sc.makeRDD(List((1, "a"), (1, "a"), (1, "a"), (2, "b"), (3, "c"), (3, "c"))) // 统计每种 key 的个数 
val result: collection.Map[Int, Long] = rdd.countByKey()