Spark-RDD 转换算子（Value 类型）

已于 2023-03-10 14:18:32 修改
阅读量482 收藏 2
点赞数
分类专栏： Spark 文章标签： spark 大数据 分布式
于 2023-03-09 22:02:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dafsq/article/details/129408452
版权

        

1、map

2、mapPartitions 

3、mapPartitionsWithIndex

4、flatMap

5、glom

6、groupBy 

7、filter

8、sample

9、distinct

10、coalesce

11、repartition

12、sortBy

        转换算子其实就是RDD中对数据进行封装转换的方法。

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

1、map

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

def map[U: ClassTag](f: T => U): RDD[U]
def main(args: Array[String]): Unit = {
    //准备环境
    //"*"代表线程的核数   应用程序名称"RDD"
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    val sc = new SparkContext(sparkConf)
    val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4,5,6))
    //算子map
      //转换函数
    def mapFun(num:Int): Int ={ //完成乘2操作
      num * 2
    }

    //map（传入的参数为函数）
    val mpRDD: RDD[Int] = rdd.map(mapFun)

    mpRDD.collect().foreach(println) //输出检验
    //关闭环境
    sc.stop()
  }

        但是一般情况方法内参数函数使用致简原则匿名函数作为参数

val mpRDD: RDD[Int] = rdd.map(_*2) //完成乘2操作

        map体现RDD的并行计算 

 def main(args: Array[String]): Unit = {
    //准备环境
    //"*"代表线程的核数   应用程序名称"RDD"
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    val sc = new SparkContext(sparkConf)
    val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4,5,6),1)//一个分区

    //1、rdd计算一个分区内的数据一个一个执行逻辑
    //当一个数据的流程全部执行后才会执行下一条数据 分区内数据的执行是有序的

    //2、不同分区的数据分区的计算是无序的
    val mpRDD1: RDD[Int] = rdd.map(
      num => {
        println("num操作1=>"+num)
        num
      }
    )

val mpRDD2: RDD[Int] = mpRDD1.map(
num => {
  println("num操作2=>"+num)
  num
}
  )

  mpRDD2.collect()
  //关闭环境
  sc.stop()
}

         当分区为1时 

        当分区为2时 

2、mapPartitions 

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

def mapPartitions[U: ClassTag](
 f: Iterator[T] => Iterator[U],
 preservesPartitioning: Boolean = false): RDD[U]
  • 可以以分区为单位作为数据转换操作
  • 缺点：但是它会把分区的数据加载到内存中进行引用 如果处理完了数据它不会释放内存因为它存在对象的引用。
  •  内存较小 数据量较大容易出现内存溢出的情况
def main(args: Array[String]): Unit = {
    //准备环境
    //"*"代表线程的核数   应用程序名称"RDD"
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    val sc = new SparkContext(sparkConf)
    val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4,5,6),2)//2个分区

    //mapPartitions(迭代器) 一次性处理一个分区的数据处理完成后再处理下一个分区的数据
    val mapRDD: RDD[Int] = rdd.mapPartitions(
      iter => {
        println("------") //输出现几次则有几个分区
        iter.map(_ * 2)
      }
    )
    mapRDD.collect().foreach(println)
  //关闭环境
  sc.stop()
}

3、mapPartitionsWithIndex

        将待处理的数据以分区为单位发送到计算节点进行处理，这里的处理是指可以进行任意的处 理，哪怕是过滤数据，在处理时同时可以获取当前分区索引。

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

        只保留打印第二个分区的数据 

def main(args: Array[String]): Unit = {
    //准备环境
    //"*"代表线程的核数   应用程序名称"RDD"
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    val sc = new SparkContext(sparkConf)
    val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4,5,6),2)//2个分区

    //需求功能： 只保留打印第二个分区的数据
    val mpiRDD: RDD[Int] = rdd.mapPartitionsWithIndex(
      (index, iter) => {
        if (index == 1) { //打印索引为1的分区 即第二个分区
          iter
        } else {
          Nil.iterator
        }
      }
    )
    mpiRDD.collect().foreach(println)
  //关闭环境
  sc.stop()

         显示改数据属于哪个分区

def main(args: Array[String]): Unit = {
    //准备环境
    //"*"代表线程的核数   应用程序名称"RDD"
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    val sc = new SparkContext(sparkConf)
    val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4,5,6),4)//4个分区

    //需求功能：显示改数据属于哪个分区
    val mpiRDD = rdd.mapPartitionsWithIndex(
      (index, iter) => {
        iter.map(
          num => {
            ("分区号"+index+"数据："+num)
          }
        )
      }
    )
    mpiRDD.collect().foreach(println)
  //关闭环境
  sc.stop()
  }

 4、flatMap

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

def flatMap[U: ClassTag](f: T => TraversableOnce[U]): RDD[U]
def main(args: Array[String]): Unit = {
    //准备环境
    //"*"代表线程的核数   应用程序名称"RDD"
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    val sc = new SparkContext(sparkConf)

    val rdd: RDD[List[Int]] = sc.makeRDD(List(List(1,2),List(3,4)))
    //把rdd中的List中的List分成个体
    val fltRDD: RDD[Int] = rdd.flatMap(
      list => {
        list
      }
    )
    fltRDD.collect().foreach(println)
  //关闭环境
  sc.stop()
  }

5、glom

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

def glom(): RDD[Array[T]]
def main(args: Array[String]): Unit = {
    //准备环境
    //"*"代表线程的核数   应用程序名称"RDD"
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    val sc = new SparkContext(sparkConf)

    val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4),2) //分区：2
    //List => Int
    //Int => Array
    val gRDD: RDD[Array[Int]] = rdd.glom()

    gRDD.collect().foreach(i => println(i.mkString(",")))
  //关闭环境
  sc.stop()
  }

        计算所有分区最大值求和（分区内取最大值，分区间最大值求和） 

def main(args: Array[String]): Unit = {
    //准备环境
    //"*"代表线程的核数   应用程序名称"RDD"
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    val sc = new SparkContext(sparkConf)

    val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4),2) //分区：2

    val grdd: RDD[Array[Int]] = rdd.glom()
    val maxRDD: RDD[Int] = grdd.map(
      arr => {
        arr.max
      }
    )
    println(maxRDD.collect().sum)

  //关闭环境
  sc.stop()
  }

6、groupBy 

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

        一个组的数据在一个分区中，但是并不是说一个分区中只有一个组

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

def main(args: Array[String]): Unit = {
    //准备环境
    //"*"代表线程的核数   应用程序名称"RDD"
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    val sc = new SparkContext(sparkConf)

    val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4),2) //分区：2
    //groupBy会将数据源中每一个数据进行分组判断，根据返回的分组Key进行分组
    //相同的Key数据会放置在一个组中
      //groupBy(参数为分组条件的函数)
    val gpRDD: RDD[(Int, Iterable[Int])] = rdd.groupBy(
      num => num % 2
    )
    gpRDD.collect().foreach(println)

  //关闭环境
  sc.stop()
  }

 7、filter

        将数据根据指定的规则进行筛选过滤，符合规则的数据保留，不符合规则的数据丢弃。 当数据进行筛选过滤后，分区不变

        但是分区内的数据可能不均衡，生产环境下，可能会出 现数据倾斜。 

def filter(f: T => Boolean): RDD[T]
def main(args: Array[String]): Unit = {
    //准备环境
    //"*"代表线程的核数   应用程序名称"RDD"
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    val sc = new SparkContext(sparkConf)

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

    //需求：过滤偶数留下奇数
    val fRDD: RDD[Int] = rdd.filter(num => num%2 !=0)

    fRDD.collect().foreach(println)

  //关闭环境
  sc.stop()
  }

8、sample

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

def sample(
 withReplacement: Boolean, //抽取完受否放回
 fraction: Double, //比例
 seed: Long = Utils.random.nextLong): RDD[T] //随机数种子（基准值）
 )
def main(args: Array[String]): Unit = {
    //准备环境
    //"*"代表线程的核数   应用程序名称"RDD"
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    val sc = new SparkContext(sparkConf)

    val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4,5,6,7,8,9,10))

    //sample(抽取后是否放回，每条数据被抽取的概率,随机算法的种子)
    //如果传染第3个参数则每次抽取的数据是固定的 不传的话就是使用当前系统时间则是随机的
    println(rdd.sample(
      false,
      0.5,
      1
    ).collect().mkString(","))
    
  //关闭环境
  sc.stop()
  }

9、distinct

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

def distinct()(implicit ord: Ordering[T] = null): RDD[T]
def distinct(numPartitions: Int)(implicit ord: Ordering[T] = null): RDD[T]
def main(args: Array[String]): Unit = {
    //准备环境
    //"*"代表线程的核数   应用程序名称"RDD"
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    val sc = new SparkContext(sparkConf)

    val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4,5,1,2,3,4,5))
    //去重
    val dRDD = rdd.distinct()
    dRDD.collect().foreach(println)

  //关闭环境
  sc.stop()
  }

10、coalesce

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

def coalesce(numPartitions: Int, shuffle: Boolean = false,
 partitionCoalescer: Option[PartitionCoalescer] = Option.empty)
 (implicit ord: Ordering[T] = null)
 : RDD[T]
def main(args: Array[String]): Unit = {
    //准备环境
    //"*"代表线程的核数   应用程序名称"RDD"
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    val sc = new SparkContext(sparkConf)

    val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4),4) //4个分区
    //缩减分区可能会导致数据倾斜
    //需要使数据均衡则要使用shuffle处理
    //coalesce(参数为分区数量,是否进行shuffle处理)
    val newRDD: RDD[Int] = rdd.coalesce(2,true) //合并为2个分区

    newRDD.saveAsTextFile("output")
  //关闭环境
  sc.stop()
  }

11、repartition

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

def repartition(numPartitions: Int)(implicit ord: Ordering[T] = null): RDD[T]
 def main(args: Array[String]): Unit = {
    //准备环境
    //"*"代表线程的核数   应用程序名称"RDD"
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    val sc = new SparkContext(sparkConf)

    val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4),2) //2个分区

    //repartition底层就是调用的coalesce 且增加了shuffle条件
    val newRDD: RDD[Int] = rdd.repartition(4) //扩大为4个分区

    newRDD.saveAsTextFile("output")
  //关闭环境
  sc.stop()
  }

12、sortBy

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

def sortBy[K](
 f: (T) => K,
ascending: Boolean = true,
 numPartitions: Int = this.partitions.length)
 (implicit ord: Ordering[K], ctag: ClassTag[K]): RDD[T]

def main(args: Array[String]): Unit = {
    //准备环境
    //"*"代表线程的核数   应用程序名称"RDD"
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    val sc = new SparkContext(sparkConf)

    val rdd: RDD[Int] = sc.makeRDD(List(2,1,6,5,9,4,8,7),2) //2个分区
    //sortBy(排序规则)
    val SRDD: RDD[Int] = rdd.sortBy(n=>n)
    //存在 shuffle 的过程
    SRDD.saveAsTextFile("output")

  //关闭环境
  sc.stop()
  }

open_test01
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Spark-RDD.md
08-09
Spark_RDD
【Spark】Spark 转换算子详解
beautiful_huang的博客
02-05 1358
文章目录一、简介二、转换算子详解map、flatMap、distinctcoalesce 和 repartitionrandomSplitglomunionsubtrat 一、简介 转换（Transformation）算子就是对RDD进行操作的接口函数，其作用是将一个或多个RDD变换成新的RDD。 使用Spark进行数据计算，在利用创建算子生成RDD后，数据处理的算法设计和程序编写的最关键部分，...
Spark中RDD常见的算子：Value 类型、双 Value 类型、Key - Value 类型
weixin_44870066的博客
12-03 1183
Spark常见的算子
Spark RDD 转换算子
m0_72168501的博客
01-20 1515
Spark RDD算子，主要分为转换类型的算子和行动类型的算子，分别进行介绍
Java使用Spark进行数据转换的常用方法和案例
qq_37480069的博客
05-30 1606
本文介绍了Java使用Spark进行数据转换的方法和案例，包括map、filter、reduce、join等方法，以及单词计数、排序、分组等案例。Spark提供了丰富的API和工具，可以帮助我们快速、高效地处理大数据。
【Spark】Spark的常用算子
weixin_46429290的博客
03-07 2301
使用给定的函数对 RDD 的元素进行聚合，seqOp 计算在分区中初始值到中间结果的聚合计算，而 combOp 在节点上对中间结果进行聚合。: 返回对输入 RDD 和参数 RDD 执行联合操作的结果，生成一个新的 RDD，不去重。: 返回对输入 RDD 和参数 RDD 执行交集操作的结果，生成一个新的 RDD。: 返回对输入 RDD 和参数 RDD 执行差集操作的结果，生成一个新的 RDD。: 返回对输入 RDD 和参数 RDD 执行笛卡尔积的结果，生成一个新的 RDD。
Spark RDD数据操作函数以及转换函数一文详解运用与方法
master_hunter的博客
04-08 4603
1.Map map是一种基础的RDD转换操作，用于将RDD中的每一个数据元素通过某种函数进行转换并返回新的RDD。 例： val distData = List(1, 3, 45, 3, 76) val sq_dist = distData.map(x => x * x) print(sq_dist) List(1, 9, 2025, 9, 5776) 2.SortBy() sortBy()是对标准RDD进行排序的方法，在org.apache.spark.rdd.RDD类中实现：
大数据培训之RDD的转换
zjjcchina的博客
09-19 1074
1.14 sortBy(func,[ascending], [numTasks]) 案例。1.15 pipe(command, [envVars]) 案例。（2）将每个分区的数据放到一个数组并收集到Driver端打印。1.10 distinct([numTasks])) 案例。（2）使每个元素跟所在分区形成一个元组组成一个新的RDD。1.4 map()和mapPartition()的区别。1.5 flatMap(func) 案例。（2）使每个元素*2组成新的RDD。（2）创建一个只有一个分区的RDD。
Spark转换算子大全以及案例实操
楚生辉的博客
10-24 7041
大家好，我是楚生辉，在未来的日子里我们一起来学习大数据相关的技术，一起努力奋斗，遇见更好的自己！RDD转换算子实际上就是换了名称的RDD方法RDD 根据数据处理方式的不同将算子整体上分为 Value 类型、双 Value 类型和 Key-Value 类型算子：Operator(操作)
Spark常用算子之转换算子
糊里糊涂走进大数据的小菜鸡
12-30 1903
Spark是一种基于内存的通用计算框架，使用Scala语言实现，是一种面向对象、函数式编程语言，能够像操作本地集合对象一样轻松的操作分布式数据集。
spark-rdd-APi
12-14
内容根据spark rdd.scala和ParRDDFunctions.scala源码中rdd顺序整理，包含rdd功能解释。对熟悉spark rdd很有用
Spark1.4.1 RDD算子详解
03-02
结合代码详细描述RDD算子的执行流程，并配上执行流程图
spark-rdd-sample1
04-29
spark-rdd-sample1
spark-RDD的特性介绍及源码阅读必备基础
04-07
spark-RDD的特性介绍及源码阅读必备基础
spark学习：java版JavaRDD与JavaPairRDD的互相转换
热门推荐
hellozhxy的博客
09-03 1万+
1。引发：做一个java读取hbase的注册成表的程序。但是读出来的是javaPairRDD，而网上都是javaRDD转成dataFrame,我只能自己摸索怎么转成javaRDD  2。方法  　　JavaRDD => JavaPairRDD: 通过mapToPair函数  　　JavaPairRDD => JavaRDD: 通过map函数转换  3。不管其他先运行一下 packa...
Spark SQL JAVA和Scala编写Spark SQL程序实现RDD转换成DataFrame+操作HiveContext+操作Mysql
Transkai
08-16 333
一、 以编程方式执行Spark SQL查询 1． 编写Spark SQL程序实现RDD转换成DataFrame 前面我们学习了如何在Spark Shell中使用SQL完成查询，现在我们通过IDEA编写Spark SQL查询程序。 Spark官网提供了两种方法来实现从RDD转换得到DataFrame，第一种方法是利用反射机制，推导包含某种类型的RDD，通过反射将其转换为指定类型的DataFrame...
scala RDD算子
墨染的博客
10-04 947
scala RDD算子 map ​ 当使用map时，对于List(1,2,3,4)，前面分区后会分成两个区 import org.apache.spark.rdd.RDD import org.apache.spark.{SparkConf, SparkContext} object rdd_partiton_map { def main(args: Array[String]): Unit = { val sparkConf = new SparkConf().set("spark.tes
Spark的RDD转换算子
m0_67614284的博客
05-04 1084
[](()4. flatMap 函数定义 def flatMap[U: ClassTag](f: T => TraversableOnce[U]): RDD[U] 说明 将处理的数据进行扁平化后再进行映射处理，所以算子也称之为扁平映射 。 案例实操 package com.atguigu.bigdata.spark.core.rdd.operator.transform import org.apache.spark.rdd.RDD import org.apache.spark.{SparkConf
Scala Spark的使用
qq_22511813的博客
11-13 603
SparkContext的创建 "#创建一个SparkConf" val work: SparkConf = new SparkConf().setMaster("local[*]").setAppName("work") "#创建一个SparkContext" val sc = new SparkContext(work) Spark的基本操作 "#从内存中创建一个RDD" val listR...
sparkrdd转换算子
最新发布
03-18
以下是一些常见的Spark RDD转换算子： 1. map(func)：对RDD中的每个元素应用给定的函数，返回一个新的RDD，新RDD中的每个元素都是原RDD中元素经过函数处理后的结果。 2. filter(func)：对RDD中的每个元素应用给定...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

open_test01

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值