10.RDD用法

最新推荐文章于 2023-05-21 11:43:40 发布

GC??

最新推荐文章于 2023-05-21 11:43:40 发布

阅读量312

点赞数

分类专栏： Spark学习笔记概念文章标签： scala spark big data

本文链接：https://blog.youkuaiyun.com/GCPOP/article/details/125325620

版权

Spark学习笔记概念专栏收录该内容

15 篇文章

订阅专栏

本文详细介绍了Spark中RDD的转换算子，包括map、mapPartitions、flatMap、glom、groupBy、filter、sample、distinct、coalesce、repartition、sortBy、intersection、union、partitionBy、reduceByKey和join等，探讨了它们的功能、使用场景和性能特点。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

RDD用法

1. RDD转换算子

1.1 概述

RDD根据数据处理方式的不同将算子整体上分为Value类型、双Value类型和Key-Value类型

1.2 map方法

函数签名

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

函数说明
- 将处理的数据逐条进行映射转换，这里的转换可以是类型的转换，也可以是值的转换。

用法

package com.gec.bigdata.spark.rdd.operator.transform

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

object Spark01_RDD_Oper_Transform {

    def main(args: Array[String]): Unit = {

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

        // TODO 算子 - 转换 - map
        val rdd = sc.makeRDD(List(1,2,3,4))

        // map算子表示将数据源中的每一条数据进行处理
        // map算子的参数是函数类型： Int => U(不确定)
        def mapFunction( num : Int ): Int = {
            num * 2
        }

        // A => B
        //val rdd1: RDD[Int] = rdd.map(mapFunction)
        val rdd1: RDD[Int] = rdd.map(_ * 2)

        rdd1.collect().foreach(println)


        sc.stop()

    }
}

1.3 mapPartitions方法

函数签名

def mapPartitions[U: ClassTag](

  f: Iterator[T] => Iterator[U],

  preservesPartitioning: Boolean = false): RDD[U]

函数说明

将待处理的数据以分区为单位发送到计算节点进行处理，这里的处理是指可以进行任意的处理，哪怕是过滤数据。

package com.gec.bigdata.spark.rdd.operator.transform

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

object Spark02_RDD_Oper_Transform {

    def main(args: Array[String]): Unit = {

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

        // TODO 算子 - 转换 -
        val rdd = sc.makeRDD(List(1,2,3,4), 2)

        val rdd1 = rdd.mapPartitions(
            list => {
                println("*********************")
                list.map(_*2)
            }
        )

        rdd1.collect().foreach(println)


        sc.stop()

    }
}

小功能：获取每个数据分区的最大值

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-w0ka0mjo-1655396109919)(assets/clip_image002.jpg)] 思考一个问题：map和mapPartitions的区别？

数据处理角度

Map算子是分区内一个数据一个数据的执行，类似于串行操作。而mapPartitions算子是以分区为单位进行批处理操作。

功能的角度

Map算子主要目的将数据源中的数据进行转换和改变。但是不会减少或增多数据。MapPartitions算子需要传递一个迭代器，返回一个迭代器，没有要求的元素的个数保持不变，所以可以增加或减少数据 性能的角度

Map算子因为类似于串行操作，所以性能比较低，而是mapPartitions算子类似于批处理，所以性能较高。但是mapPartitions算子会长时间占用内存，那么这样会导致内存可能不够用，出现内存溢出的错误。所以在内存有限的情况下，不推荐使用。使用map操作。

完成比完美更重要

1.4 flatMap

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sIC4Ep2X-1655396109920)(assets/1652194680569.png)]

函数签名

def flatMap[U: ClassTag](f: T => TraversableOnce[U]): RDD[U]

函数说明

将处理的数据进行扁平化后再进行映射处理，所以算子也称之为扁平映射

package com.gec.demo
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

object Spark_WordCount {

  def main(args: Array[String]): Unit = {

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

    // TODO 算子 - 转换 - 扁平化
    val rdd = sc.makeRDD(
      List(
        "Hello Scala", "Hello Spark"
      )
    )
    val rdd1 = sc.makeRDD(
      List(
        List(1,2), List(3,4)
      )
    )

    // 整体 => 个体
    //val rdd2 = rdd.flatMap(_.split(" "))
    val rdd2 = rdd.flatMap(
      str => { // 整体（1）
        // 容器（个体（N））
        str.split(" ")
      }
    )

    val rdd3 = rdd1.flatMap(
      list => {
        list
      }
    )

    rdd2.collect().foreach(println)
    rdd3.collect().foreach(println)


    sc.stop()
  }
}

1.5 glom

函数签名
```
def glom(): RDD[Array[T]]
```

函数说明

将同一个分区的数据直接转换为相同类型的内存数组进行处理，分区不变

package com.gec.bigdata.spark.rdd.operator.transform

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

object Spark05_RDD_Oper_Transform {

    def main(args: Array[String]): Unit = {

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

        // TODO 算子 - 转换 - 扁平化
        val rdd : RDD[Int] = sc.makeRDD(List(1,2,3,4,5,6), 2)

        val rdd1: RDD[Array[Int]] = rdd.glom()

        rdd1.collect().foreach(a => println(a.mkString(",")))


        sc.stop()

    }
}

1.6 groupBy

函数签名

def groupBy[K](f: T => K)(implicit kt: ClassTag[K]): RDD[(K, Iterable[T])]

函数说明

将数据根据指定的规则进行分组, 分区默认不变，但是数据会被打乱重新组合，我们将这样的操作称之为shuffle。极限情况下，数据可能被分在同一个分区中一个组的数据在一个分区中，但是并不是说一个分区中只有一个组

package com.gec.demo
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

object Spark_WordCount {

  def main(args: Array[String]): Unit = {

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

    // TODO 算子 - 转换
    val rdd : RDD[Int] = sc.makeRDD(List(1,2,3,4,5,6))

    // groupBy算子根据函数计算结果进行分组。
    // groupBy算子执行结果为KV数据类型
    //     k是为分组的标识， v就是同一个组的数据集合
    val rdd1: RDD[(Int, Iterable[Int])] = rdd.groupBy(_ % 2)
    //rdd1.mapValues()
    // 1 => 1
    // 2 => 0
    // 3 => 1
    // 4 => 0
    // 5 => 1
    // 6 => 0

    rdd1.collect.foreach(println)





    sc.stop()
  }
}

1.7 filter

函数签名
```
def filter(f: T => Boolean): RDD[T]
```

函数说明

将数据根据指定的规则进行筛选过滤，符合规则的数据保留，不符合规则的数据丢弃。当数据进行筛选过滤后，分区不变，但是分区内的数据可能不均衡，生产环境下，可能会出现数据倾斜。

package com.gec.bigdata.spark.rdd.operator.transform

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

object Spark07_RDD_Oper_Transform {

    def main(args: Array[String]): Unit = {

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

        // TODO 算子 - 转换
        val rdd : RDD[Int] = sc.makeRDD(List(1,2,3,4,5,6))

        // filter算子可以按照指定的规则对每一条数据进行筛选过滤
        // 数据处理结果为true，表示数据保留，如果为false，数据就丢弃
        val rdd1 = rdd.filter(
            num => num % 2 == 1
        )

        rdd1.collect.foreach(println)



        sc.stop()

    }
}

1.10 sample

函数签名

def sample(

 withReplacement: Boolean,

 fraction: Double,

 seed: Long = Utils.random.nextLong): RDD[T]

函数说明

根据指定的规则从数据集中抽取数据

    val conf = new SparkConf().setMaster("local[*]").setAppName("RDD")

        val sc = new SparkContext(conf)

        // TODO 算子 - 转换
        val rdd : RDD[Int] = sc.makeRDD(1 to 10)

        // 抽取数据，采样数据
        // 第一个参数表示抽取数据的方式：true. 抽取放回，false. 抽取不放回
        // 第二个参数和第一个参数有关系
        //     如果抽取不放回的场合：参数表示每条数据被抽取的几率
        //     如果抽取放回的场合：参数表示每条数据希望被重复抽取的次数
        // 第三个参数是【随机数】种子
        //     随机数不随机，所谓的随机数，其实是通过随机算法获取的一个数
        //     3 = xxxxx(10)
        //     7 = xxxxx(3)
        //val rdd1: RDD[Int] = rdd.sample(false, 0.5)
        //val rdd1: RDD[Int] = rdd.sample(true, 2)
        val rdd1: RDD[Int] = rdd.sample(false, 0.5, 2)
        rdd1.collect.foreach(println)


        sc.stop()

1.11 distinct

函数签名

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

函数说明

将数据集中重复的数据去重

// TODO 算子 - 转换
val rdd : RDD[Int] = sc.makeRDD(
List(1,1,1)
)

val rdd1: RDD[Int] = rdd.distinct()
rdd1.collect.foreach(println)

1.12 coalesce

函数签名

def coalesce(numPartitions: Int, shuffle: Boolean = false,
partitionCoalescer: Option[PartitionCoalescer] = Option.empty)
(implicit ord: Ordering[T] = null): RDD[T]

函数说明

根据数据量缩减分区，用于大数据集过滤后，提高小数据集的执行效率当spark程序中，存在过多的小任务的时候，可以通过coalesce方法，收缩合并分区，减少分区的个数，减小任务调度成本

		val conf = new SparkConf().setMaster("local[*]").setAppName("RDD")
        conf.set("spark.local.dir", "e:/test")
        val sc = new SparkContext(conf)

        // TODO 算子 - 转换 - 缩减分区
        val rdd : RDD[Int] = sc.makeRDD(
            List(1,2,3,4,5,6), 3
        )

        // 缩减 (合并)， 默认情况下，缩减分区不会shuffle
        //val rdd1: RDD[Int] = rdd.coalesce(2)
        // 这种方式在某些情况下，无法解决数据倾斜问题，所以还可以在缩减分区的同时，进行数据的shuffle操作
        val rdd2: RDD[Int] = rdd.coalesce(2, true)

        rdd.saveAsTextFile("output")
        rdd2.saveAsTextFile("output1")




        sc.stop()

1.13 repartition

函数签名

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

函数说明

该操作内部其实执行的是coalesce操作，参数shuffle的默认值为true。无论是将分区数多的RDD转换为分区数少的RDD，还是将分区数少的RDD转换为分区数多的RDD，repartition操作都可以完成，因为无论如何都会经shuffle过程。

package com.gec.bigdata.spark.rdd.operator.transform

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

object Spark10_RDD_Oper_Transform_1 {

    def main(args: Array[String]): Unit = {

        val conf = new SparkConf().setMaster("local[*]").setAppName("RDD")
        conf.set("spark.local.dir", "e:/test")
        val sc = new SparkContext(conf)

        // TODO 算子 - 转换 - 缩减分区
        val rdd : RDD[Int] = sc.makeRDD(
            List(1,2,3,4,5,6), 2
        )

        // 扩大分区 - repartition
        // 在不shuffle的情况下，coalesce算子扩大分区是没有意义的。
        //val rdd1: RDD[Int] = rdd.coalesce(3, true)

        val rdd1: RDD[Int] = rdd.repartition(3)


        rdd.saveAsTextFile("output")
        rdd1.saveAsTextFile("output1")




        sc.stop()

    }
}

1.14 sortBy

函数签名

def sortBy[K](

 f: (T) => K,

 ascending: Boolean = true,

 numPartitions: Int = this.partitions.length)

 (implicit ord: Ordering[K], ctag: ClassTag[K]): RDD[T]

函数说明

该操作用于排序数据。在排序之前，可以将数据通过f函数进行处理，之后按照f函数处理的结果进行排序，默认为升序排列。排序后新产生的RDD的分区数与原RDD的分区数一致。中间存在shuffle的过程


val dataRDD = sparkContext.makeRDD(List(

  1,2,3,4,1,2

),2)

val dataRDD1 = dataRDD.sortBy(num=>num, false, 4)

1.15 intersection

函数签名

def intersection(other: RDD[T]): RDD[T]

函数说明

- 对源RDD和参数RDD求交集后返回一个新的RDD

package com.gec.demo1
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

object Flat_map {

  def main(args: Array[String]): Unit = {

    val conf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    val sparkContext = new SparkContext(conf)

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

    dataRDD.foreach(println(_))

  }

}

1.16 union

函数签名
```
def union(other: RDD[T]): RDD[T]
```

函数说明

对源RDD和参数RDD求并集后返回一个新的RDD

val dataRDD1 = sparkContext.makeRDD(List(1,2,3,4))

val dataRDD2 = sparkContext.makeRDD(List(3,4,5,6))

val dataRDD = dataRDD1.union(dataRDD2)

1.18 partitionBy

函数签名

def partitionBy(partitioner: Partitioner): RDD[(K, V)]

函数说明

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

package com.gec.demo1
import org.apache.spark.rdd.RDD
import org.apache.spark.{HashPartitioner, SparkConf, SparkContext}

object Flat_map {

  def main(args: Array[String]): Unit = {

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

    val rdd : RDD[Int] = sc.makeRDD(
      List(1,2,3,4),2
    )
    val rdd1: RDD[(Int, Int)] = rdd.map((_, 1))
    rdd1.partitionBy(new HashPartitioner(2)).saveAsTextFile("output");
  }

}

1.19 reduceByKey

函数签名

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

函数说明

可以将数据按照相同的Key对Value进行聚合

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

1.20 join

函数签名

def join[W](other: RDD[(K, W)]): RDD[(K, (V, W))]

函数说明
- 在类型为(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)

numPartitions: Int): RDD[(K, V)]


- 函数说明

可以将数据按照相同的Key对Value进行聚合

~~~ scala
val dataRDD1 = sparkContext.makeRDD(List(("a",1),("b",2),("c",3)))
val dataRDD2 = dataRDD1.reduceByKey(_+_)
val dataRDD3 = dataRDD1.reduceByKey(_+_, 2)

1.20 join

函数签名

def join[W](other: RDD[(K, W)]): RDD[(K, (V, W))]

函数说明
- 在类型为(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)