9.RDD用法

本文详细介绍了Spark中的RDD用法,包括从内存、文件创建RDD,RDD的并行度与分区概念,以及map、mapPartitions、flatMap、glom、groupBy、filter、reduceByKey和join等转换算子的使用和特点。

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

RDD用法

1. 基础编程

1.1 RDD创建

  • 在Spark中创建RDD的创建方式可以分为四种

1.1.1 从集合(内存)中创建RDD

  • 从集合中创建RDD,Spark主要提供了两个方法:parallelize和makeRDD

    val sparkConf =new SparkConf().setMaster("local[*]").setAppName("spark")
    
    val sparkContext = new SparkContext(sparkConf)
    
    val rdd1 = sparkContext.parallelize(
      List(1,2,3,4)
    )
    
    val rdd2 = sparkContext.makeRDD(
      List(1,2,3,4)
    )
    
    rdd1.collect().foreach(println)
    rdd2.collect().foreach(println)
    sparkContext.stop()
    

1.1.2 从外部存储(文件)创建RDD

  • 由外部存储系统的数据集创建RDD包括:本地的文件系统,所有Hadoop支持的数据集,比如HDFS、HBase等。

    val sparkConf =new SparkConf().setMaster("local[*]").setAppName("spark")
    val sparkContext = new SparkContext(sparkConf)
    val fileRDD: RDD[String] = sparkContext.textFile("input")
    fileRDD.collect().foreach(println)
    sparkContext.stop()
    

1.1.3 从其他RDD创建

  • 主要是通过一个RDD运算完后,再产生新的RDD。

1.1.4 直接创建RDD

  • 使用new的方式直接构造RDD,一般由Spark框架自身使用。

2.2 RDD并行度与分区

2.2.1 概述

  • 默认情况下,Spark可以将一个作业切分多个任务后,发送给Executor节点并行计算,而能够并行计算的任务数量我们称之为并行度。这个数量可以在构建RDD时指定。

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

2.2.2 分区

 val conf = new SparkConf().setMaster("local[*]").setAppName("RDD")
        conf.set("spark.default.parallelism", "4")
        val sc = new SparkContext(conf)

        // TODO 从内存中创建RDD - 分区

        // 1. 如果构建RDD时,没有指定数据处理分区的数量,那么会使用默认分区数量
        // makeRDD方法存在第二个参数,这个参数表示分区数量numSlices(存在默认值)
        // scheduler.conf.getInt("spark.default.parallelism", totalCores)
        // totalCores : 当前Master环境的总(虚拟)核数
        // 分区设置的优先级 : 方法参数 > 配置参数 > 环境配置

        // kafka生产者分区策略
        // 【1,3,5】【2,4】 : 轮询
        // 【1,2, 3】【5,4】 :范围
        // 【1,2】【3,4】【5】 :范围
        // Spark分区策略
        // 【1,2】【3,4,5】 :范围
        // 【1】【2,3】【4,5】:范围
        val rdd1 : RDD[Int] = sc.makeRDD(
            Seq(1,2,3,4,5), 3
        )

        // saveAsTextFile方法可以生成分区文件
        rdd1.saveAsTextFile("output")


        sc.stop()

3.3 RDD转换算子

3.3.1 概述

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

3.3.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()
    
        }
    }
    
    

3.3.3 mapPartitions方法

  • 函数签名

    def mapPartitions[U: ClassTag](
    
      f: Iterator[T] => Iterator[U],
    
      preservesPartitioning: Boolean = false): RDD[U]
    
  • 函数说明

    • 将待处理的数据以分区为单位发送到计算节点进行处理,这里的处理是指可以进行任意的处理,哪怕是过滤数据。
    package com.atguigu.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-axu2Hxs9-1655396045047)(assets/clip_image002.jpg)] 思考一个问题:map和mapPartitions的区别?

数据处理角度

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

功能的角度

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

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

完成比完美更重要

3.3.4 flatMap

  • 函数签名

    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()
        }
      }
      
      

3.3.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()
      
          }
      }
      
      

3.3.5 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()
      }
    }
    
    

3.3.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()
      
          }
      }
      
      

3.3.8 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)
  • 小功能:WordCount

3.3.9 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)
    

yKey(+, 2)


- 小功能:WordCount

### 3.3.9 join

- 函数签名

  ~~~ scala
  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)
    
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值