spark之RDD的转换算子与行为算子的具体使用

最新推荐文章于 2024-04-10 22:24:15 发布
最新推荐文章于 2024-04-10 22:24:15 发布
阅读量1.2k 收藏
点赞数 1
文章标签： spark big data scala
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45992615/article/details/122300696
版权

文章目录

1、Transform算子

1.1 map

package com.shujia.core

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

/**
  * @return ：danzhu努力学bigdata
  *
  *         1、转换算子：由一个RDD变成另一个RDD，是RDD之间的转换,是懒执行的
  *
  *         2、行为算子：由一个RDD调用，但是最后没有返回新的RDD，而是返回了其他数据类型
  *                    行为算子可以触发任务的执行，每个actions 算子都会触发一个任务
  *
  */
object SparkRDDMap {
  def main(args: Array[String]): Unit = {
    /**
      * map算子
      */
    //创建spark的上下文环境
    val conf: SparkConf = new SparkConf()
    conf.setAppName("SparkRDDdemo1")
    conf.setMaster("local")
    val sc: SparkContext = new SparkContext(conf)
    /**
      * RDD的创建方式：
      * 1、通过textFile读取文件
      * 2、通过集合创建RDD（一般用于测试）
      */
    //textFile是读取文件的RDD形式，parallelize是创建一个list集合的方式
    /**
      * map是转换算子，是懒执行的，
      *需要接收一个函数f:参数为RDD中的泛型，返回值类型自定
      * 会将每一条数据一次传给函数f进行转换
      * 最终整个map方法完成后会返回一个新的RDD
      *
      */
    val listRDD: RDD[Int] = sc.parallelize(List(1, 2, 3, 4, 5, 6, 7, 8, 9))

    /**
      * 在算子的外部是在driver端运行的，而在算子内部是在executor端执行的
      */
    //println("map之前")
    val mapRDD: RDD[Int] = listRDD.map(i => {
      println("i的值" + i)
      i * 20
    })

    //println("map之后")
//    mapRDD.foreach(println)
//    listRDD.foreach(println)
    val JiShuRDD: RDD[Int] = listRDD.filter(i => {
      var flag: Boolean = false
      if (i % 2 == 1) {
        flag = true
      }
      flag
    })
   JiShuRDD.foreach(println)

    while (true){

    }
    
  }
  
}

1.2 flatmap

package com.shujia.core

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

import scala.collection.mutable

/**
  * @return ：danzhu努力学bigdata
  */
object SparkRDDFlatmap {
  def main(args: Array[String]): Unit = {
    /**
      * flatmap算子：转换算子
      *
      * 需要接受一个函数f：参数类型同RDD中的泛型，返回值类型是集合、数组、序列、迭代器（数据容器）
      * 会将每一条数据依次传递给函数f进行转换，还会将函数f返回的数据容器进行扁平化处理（展开）
      * 得到一个新的RDD
      */
    //创建上下文环境
    val conf: SparkConf = new SparkConf()
    conf.setAppName("SparkRDDFlatmap")
    conf.setMaster("local")
    val sc: SparkContext = new SparkContext(conf)
    val lineRDD: RDD[String] = sc.parallelize(List("java,java,scala,python","hadoop,hive,hbase","spark,filk,MapReduce"))
    val splitsRDD: RDD[String] = lineRDD.flatMap(word => {
      word.split(",")
    })
    val groupByRDD: RDD[(String, Iterable[String])] = splitsRDD.groupBy(word=>word)

    val wordcountRDD : RDD[(String, Int)] = groupByRDD.map(kv => {
      val key: String = kv._1
      val value: Iterable[String] = kv._2
      val size: Int = value.size
      (key, size)
    })

    wordcountRDD.foreach(println)
    groupByRDD.foreach(println)
    splitsRDD.foreach(println)
    lineRDD.foreach(println)
  }

}

1.3 groupBy和groupBykey

package com.shujia.core

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

/**
  * @return ：danzhu努力学bigdata
  */
object SparkRDDGroupBy {
  def main(args: Array[String]): Unit = {
    /**
      * groupBy:转换算子：需要制定按什么排名
      *
      *
      */

    //创建spark上下文的环境
    val conf: SparkConf = new SparkConf()

    conf.setAppName("SparkRDDGroupBy")
    conf.setMaster("local")
    val sc: SparkContext = new SparkContext(conf)


    //读取students数据
    val lineRDD: RDD[String] = sc.textFile("spark/data/stu/students.txt")
    //统计班级人数
    val clazzRDD: RDD[(String, Int)] = lineRDD.map(line => (line.split(",")(4), 1))
    //clazzRDD.foreach(println)
    //按班级分组
    val groupRDD: RDD[(String, Iterable[(String, Int)])] = clazzRDD.groupBy(kv => kv._1)
   // groupRDD.foreach(println)
    //统计班级人数
    val sum_clazzRDD: RDD[(String, Int)] = groupRDD.map {
      case (key: String, iter: Iterable[(String, Int)]) => {
        val clazz_sum: Int = iter.map(lin => lin._2).sum
        (key, clazz_sum)

      }
    }
    //sum_clazzRDD.foreach(println)

    /**
      * groupBykey:转换算子
      *
      * 分区类算子：分区类算子只能作用在k-v格式的RDD上
      *
      * 在当前程序中，lineRDD不是K-V格式，所以没有groupBykey算子
      * groupBykey算子默认按照key进行分组结果同groupBy类似担忧细微的差异
      * 这两个group算子都会返回kv格式
      * k:指定的分组字段（groupBy）、k-v格式的RDD的key（groupBykey）
      * V：符合相同分组条件的一个整体（groupBy）,只会返回value(groupBykey)
      */

    val groupByKeyRDD: RDD[(String, Iterable[Int])] = clazzRDD.groupByKey()
    groupByKeyRDD.map(kv=>(kv._1,kv._2.sum)).foreach(println)

  }

}

1.4 filter

package com.shujia.core

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

/**
  *
  * @return ：danzhu努力学bigdata
  */
object SparkRDDFilter{
  def main(args: Array[String]): Unit = {
    /**
      * filter:转换算子
      *  需要接收一个函数f:餐胡类型同RDD中的泛型，返回值类型时Boolean类型
      *  会根据函数f的返回值对数据进行过滤
      *   如果返回true则保留数据，返回false则将数据过滤
      */
    //创建Spark上下环境
    val conf: SparkConf = new SparkConf()

    conf.setAppName("SparkRDDFilter")
    conf.setMaster("local")
    val sc: SparkContext = new SparkContext(conf)

    //读取students数据
    val lineRDD: RDD[String] = sc.textFile("spark/data/stu/students.txt")
    //过滤除理科班学生
    lineRDD.filter(line=>{
      val splits: Array[String] = line.split(",")
      //startsWith是字符串中以某某为前缀的方法
      splits(4).startsWith("理科")
    }).foreach(println)
  }
}

1.5 Mappartitions

package com.shujia.core

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

/**
  * @return ：danzhu努力学bigdata
  */
object SparkRDDMappartitions {
  def main(args: Array[String]): Unit = {
    /**
      * Mappartitions:转换算子
      *
      */

    //创建上下文的环境
    val conf: SparkConf = new SparkConf()
    conf.setAppName("SparkRDDMappartitions")
    conf.setMaster("local")
    val sc: SparkContext = new SparkContext(conf)


    val lineRDD: RDD[String] = sc.textFile("spark/data/words")
    //对每一个分区的数据进行处理，这里有三份文件，既有三个分区，每一个分区至少对应一个task
    //适用于在算子内部需要跟外部数据源建立连接的情况
    //通过mapPartitions这种方式可以减少连接创建的次数，顺便提高运行效率
    /**
      * 使用迭代器是因为迭代器只能迭代一次就没有了（自动消失），而list可以迭代多次，
      * list在内存里，迭代器是要用的时候才会有，所以不会占用内存过多
      *
      */
    lineRDD.mapPartitions((iter: Iterator[String]) => {
      println("map partitions") //打印三次
      //迭代器也有map等方法
      iter.flatMap(line => {
        line.split(",")
      })
    }).foreach(println)

    //对每一条数据进行处理，假设有N条数据
    //如果需要在map中例如去请求mysql的数据（一般创建连接是为了获取数据），那么会与mysql建立N次连接
    //会导致运行效率较低，甚至会导致mysql建立的连接数达到上限，出现性能问题
    lineRDD.map(line => {
      println("map")
      val strings: Array[String] = line.split(",")
      strings
    }).foreach(println)
    lineRDD.mapPartitionsWithIndex((index,iter)=>{
      println("当前的分区索引："+index)
      iter.flatMap(line=>line.split(",0"))

    }).foreach(println)
  }

}

1.6 mapValues

package com.shujia.core

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

/**
  *
  * @return ：danzhu努力学bigdata
  */
object SparkRDDMapvalues {
  def main(args: Array[String]): Unit = {
    //创建spark上下文的环境
    val conf: SparkConf = new SparkConf()
    conf.setAppName("SparkRDDGroupBy")
    conf.setMaster("local")
    val sc: SparkContext = new SparkContext(conf)

//只能作用在k-v格式的RDD上，相当于对values进行遍历
    val rdd: RDD[(String, Int)] = sc.parallelize(List(("张三",1),("李四",2),("王五",3)))
    rdd.mapValues(i=>i*i).foreach(println)
  }

}

1.7 sort

package com.shujia.core

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

/**
  *
  * @return ：danzhu努力学bigdata
  */
object SparkRDDsort {
  def main(args: Array[String]): Unit = {
    //创建spark上下文的环境
    val conf: SparkConf = new SparkConf()
    conf.setAppName("SparkRDDGroupBy")
    conf.setMaster("local")
    val sc: SparkContext = new SparkContext(conf)

    val stuRDD: RDD[String] = sc.textFile("spark/data/stu/students.txt")

    //按照年龄排序，倒序
    //ascending 默认升序排序
    stuRDD.sortBy(stu=>stu.split(",")(2),ascending = false)
      .foreach(println)

  }

}

1.8 simple

package com.shujia.core

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

/**
  *
  * @return ：danzhu努力学bigdata
  */
object SparkRDDSample {
  def main(args: Array[String]): Unit = {
    /**
      * sample:转换算子
      * withReplacement:有无放回
      * fraction：抽样比例（最终抽样出来的数据量大致等于抽样比例）
      *
      */

    //创建spark上下文环境
    val conf: SparkConf = new SparkConf()
    conf.setAppName("SparkRDDSimple")
    conf.setMaster("local")
    val sc: SparkContext = new SparkContext(conf)


    val lineRDD: RDD[String] = sc.textFile("spark/data/stu/students.txt")
    val sampleRDD: RDD[String] = lineRDD.sample(false, 0.2)
    sampleRDD.foreach(println)
  }
}

1.9 union

package com.shujia.core

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

/**
  * @return ：danzhu努力学bigdata
  */
object SparkRDDUnion {
  def main(args: Array[String]): Unit = {
    //创建spark上下文的环境
    val conf: SparkConf = new SparkConf()
    conf.setAppName("SparkRDDGroupBy")
    conf.setMaster("local")
    val sc: SparkContext = new SparkContext(conf)

    //通过集合创建RDD
    /**
      * union:转换算子
      */
      //两个RDD union格式必须一致
    val rdd1: RDD[Int] = sc.parallelize(List(1,2,3,4,5,6))
    val rdd2: RDD[Int] = sc.parallelize(List(4,5,6,7,8,9))
    rdd1.union((rdd2)).foreach(println)
  }

}

2、 Actions算子

2.1 count,collect,reduce,save,lookup

package com.shujia.core

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

/**
  *
  * @return ：danzhu努力学bigdata
  */
object SparkRDDAction {
  def main(args: Array[String]): Unit = {
    //创建spark上下文的环境
    val conf: SparkConf = new SparkConf()
    conf.setAppName("SparkRDDGroupBy")
    conf.setMaster("local")
    val sc: SparkContext = new SparkContext(conf)


    //读取students、scores数据
    val stuRDD: RDD[String] = sc.textFile("spark/data/stu/students.txt")
    //foreach 没有返回值，会触发job
    //需要接收一个函数f：参数为RDD中的泛型，返回值类型为Unit
    stuRDD.foreach(println)

    /**
      * count:行为算子
      * 统计RDD中的数据
      * 注意：RDD中不保存数据，RDD只是spark的一种编程模型
      *
      */
    println(stuRDD.count())

    /**
      * collect:行为算子。将RDD 中的数转换为scala中的数组
      */
    /**
      * 在一个RDD中不能直接使用另一个RDD
      * 1、RDD是一个抽象的编程模型，没有实现序列化的
      * 2、如果在Task中使用另一个RDD，那么这个RDD的转换以及Action由谁进行调度和申请资源呢
      *
      */
    val stuArr: Array[String] = stuRDD.collect()
    val blackListRDD: RDD[String] = sc.parallelize(List("1500100001","1500100007","1500100009"))
    //我们可以在算子外部先调用collect方法然后再算子内部调用
    val ListRDD: Array[String] = blackListRDD.collect()
    stuRDD.filter(stu=>{
      ListRDD.contains(stu.split(",")(0))
    }).foreach(println)

    /**
      * reduce:行为算子
      *
      */
    //传入一个聚合函数
    //select sum(age) from students group by 1
    //全局的聚合（将所有的数据作为一个组进行聚合）
    stuRDD.map(line=>line.split(",")(2))
      .reduce((i,j)=>i+j)
    .foreach(println)
    /**
      * save:
      */
    stuRDD.saveAsTextFile("")
    /**
      * lookup:作用在k-v格式的RDD上，传入一个key,返回与之对应的value
      *
      */
    val ids: Seq[String] = stuRDD.map(line => (line.split(",")(1), line.split(",")(0)))
      .lookup("宣谷芹")
    println(ids)
  }
}

2.2 foreach 和 foreachPartition

package com.shujia.core

import java.sql.{Connection, DriverManager, PreparedStatement}

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

/**
  * @return ：danzhu努力学bigdata
  */
object SparkRDDForeach {
  def main(args: Array[String]): Unit = {
    /**
      * foreach、foreachPartition都是行为算子
      * foreach：需要接收一个函数f:参数类型同RDD中的泛型，返回值类型Unit
      * 会将每一条数据依次传递给函数f进行最终的一个处理，一般用于输出打印（测试）
      *
      * foreachPartion:需要接收一个函数f:参数类型是iterator类型，返回值类型Unit
      *  会将每个分区的数据传给Trerator并进行最终的处理，一般用于将结果保存到外部系统（mysql）
      *
      * 注意：一般算子后面跟着partition的算子，参数类型一般是迭代器（减少占用内存），
      *      这样的会迭代器还要调用其他普通算子一次
      */
    //创建上下文环境
    val conf: SparkConf = new SparkConf()
    conf.setAppName("SparkRDDForeach")
    conf.setMaster("local")
    val sc: SparkContext = new SparkContext(conf)


    //读取数据，设置了是个分区
    val lineRDD: RDD[String] = sc.textFile("spark/data/stu/students.txt", 4)
    println(lineRDD.getNumPartitions)

    //创建mysql连接

    //遍历每一条数据
    //因为不需要返回值，所以选择foreach行为算子遍历
    /**
      * 算子外部的代码在Driver端执行的
      * 算子内部的代码是以Task的形式发送到Executor中执行的
      * 连接是不能被序列化的，所以连接的建立需要放入算子内部
      *
      * //      */
    //    lineRDD.foreach(line=>{
    //      //连接是不能被序列化的，所以连接的建立需要放入算子内部
    //      //foreach是针对每一条数据处理一次，相当于这里会创建1000次连接，会造成性能问题
    //      val conn: Connection = DriverManager.getConnection("jdbc:mysql://master:3306/test?useUnicode=true&characterEncoding=UTF-8","root","123456")
    //      val ps: PreparedStatement = conn.prepareStatement("insert into student2 values(?,?,?,?,?)")
    //      val splits: Array[String] = line.split(",")
    //      val id: Int = splits(0).toInt
    //      val name: String = splits(1)
    //      val age: Int = splits(2).toInt
    //      val gender: String = splits(3)
    //      val clazz: String = splits(4)
    //      ps.setInt(1,id)
    //      ps.setString(2,name)
    //      ps.setInt(3,age)
    //      ps.setString(4,gender)
    //      ps.setString(5,clazz)
    //      ps.execute()
    //      ps.close()
    //      conn.close()
    //    })

    /**
      * 可以使用foreachpartition代替foreach完成对mysql数据的插入
      *   适用于在算子内部需要跟外部数据源建立连接（一般创建连接是为了写入数据）的情况
      *
      * //连接是不能被序列化的，所以连接的建立需要放入算子内部
      * //foreach是针对每一条数据处理一次，相当于这里会创建1000次连接，会造成性能问题
      * //对每个分区的数据进行处理，相当于每个分区建立一次连接,因为有是个分区，所以只会创建四次连接
      * //大大降低连接的次数，提高性能
      *
      *
      *
      */

    lineRDD.foreachPartition(iter => {
      val conn: Connection = DriverManager.getConnection("jdbc:mysql://master:3306/test?useUnicode=true&characterEncoding=UTF-8", "root", "123456")
      val ps: PreparedStatement = conn.prepareStatement("insert into student2 values(?,?,?,?,?)")
      //这里的foreach方法实际上不是RDD的算子，这里是Iterator的foreach方法
      //不会出现连接未被序列化的问题，当前处理的分区数据都会共用一个连接
      iter.foreach(line => {
        val splits: Array[String] = line.split(",")
        val id: Int = splits(0).toInt
        val name: String = splits(1)
        val age: Int = splits(2).toInt
        val gender: String = splits(3)
        val clazz: String = splits(4)
        ps.setInt(1, id)
        ps.setString(2, name)
        ps.setInt(3, age)
        ps.setString(4, gender)
        ps.setString(5, clazz)
        //相当于每条数据插入一次，性能也比较低
        //ps.execute()
        ps.addBatch()
      })
      //采用批量插入的方式
      ps.executeBatch()
      ps.close()
      conn.close()
    })
  }

}

说明：代码中所涉及到的数据，可以联系本人获取

努力成为咸鱼
关注
RDD常用转换算子和动作算子
qq_38497133的博客
08-06 2552
文章目录一 、转换算子1.map2. filter3.mapValues4. distinct、union、intersection5. reduceByKey、sortByKey、groupByKey6. flatMap 一 、转换算子 1.map 对RDD中的每个元素都执行一个指定的函数来产生一个新的RDD 任何原RDD中的元素在新的RDD中都有且只有一个元素与之对应 输入分区和输出分区一一对应 //创建一个spark context对象 val conf:SparkConf = new Spark
RDD常见转化算子和行动算子
是我的博客啊
05-26 988
/** * RDD被创建后是只读的，不允许被修改。spark提供了丰富的用于操作RDD的方法，这些方法被称为算子。 * 一个创建完成的RDD只支持两种算子：转化算子和行动算子。 * 转化算子： * 负责对RDD中的数据进行计算并转化为新的RDD。 * Spark中所有的转化算子都是惰性的，因为他们不会立即计算结果， * 而是记住对某个RDD的具体操作过程，直到遇到行动算子才会和行动算子一起执行。 */ 常见转化算子 val sparkConf = new SparkConf().setM
RDD的常用转换算子和行动算子
程序员杂谈
06-06 1199
-转换算子Transformation *转换算子执行完毕之后，会创建新的RDD，并不会马上执行计算 *map 对RDD中的元素进行一个个映射 *mapPartitions 以分区为单位，对RDD中的元素进行映射 *mapPartitionsWithIndex 以分区为单位，对RDD中的元素进行映射，并且带分区编号 *flatMap ...
spark 转换和行动算子
mys_35088的博客
04-28 977
1.RDD转换算子 RDD根据数据处理方式的不同将算子整体分为Value类型，双Value类型，key-value类型 一 、Vlaue类型： （1）map 函数说明： 将处理的数据逐条进行映射转换，这里的转换可以是类型的转换，也可以是值的转换 （2）mapPartitions 函数说明： 将待处理的数据以分区为单位发送到计算节点进行处理，这里的处理是指可以...
【Spark】（五）Spark Transformation（转换算子） 和 Action（执行算子）
云祁QI
01-09 2086
文章目录一、Transformation 和 Action1、转换操作2、行动操作二、map、flatMap、mapParations、mapPartitionsWithIndex2.1　map2.2　flatMap3.3　mapPartitions2.4 mapPartitionsWithIndex三、reduce、reduceByKey3.1　reduce3.2　reduceByKey四、un...
Spark的RDD转换算子与行动算子
Laoddaaa的博客
08-20 540
Spark的RDD转换算子与行动算子
SparkRDD——转换算子
tyh1579152915的博客
05-19 2929
转换算子 一、单value型转换算子（只使用1个RDD）： 1、map 将数据进行转换，数据量不会增加和减少 2、mapPartitions 以分区为单位将一个分区内的数据进行批处理操作，且可以执行过滤操作 3、mapPartitionsWithIndex 功能类似mapPartiutions算子，只是加入了每个分区的索引，可以选择性的对某些分区进行操作 4、flatMap 扁平化操作，即将集合嵌套类型的数
Spark之RDD转换算子（transformation）大全
zp17834994071的博客
08-07 4491
前面已经给大家讲过RDD原理，今天就给大家说说RDD的转换算子有哪些，以便大家理解。 对于转换操作，RDD的所有转换都不会直接计算结果，仅记录作用于RDD上的操作，当遇到动作算子（Action）时才会进行真正计算，理解了转换算子的用途，那么接下来就不能理解哪些是转换算子了，通俗的说只要没有经过聚合或计算的算子，都可以当作转换算子。 常用转换算子 map 对RDD中的每个元素都执行一个指定的函数来产生一个新的RDD 任何原RDD中的元素在新RDD中都有且只有一个元素与之对应 输入分区与输出分区一一对应 案
Spark核心编程—RDD算子(转换算子)
weixin_42570840的博客
06-13 1768
Spark核心编程、RDD转换算子
尚硅谷大数据Spark之RDD转换算子学习笔记及面试题
qq_25127933的博客
09-28 713
1. Spark 算子从功能上可以分为以下两类: 1）Transformation 变换/转换算子：这种变换并不触发提交作业，完成作业中间过程处理。Transformation 操作是延迟计算的，也就是说从一个RDD 转换生成另一个 RDD 的转换操作不是马上执行，需要等到有 Action 操作的时候才会真正触发运算。 RDD转换算子根据数据处理方式的不同将算子整体上分为Value类型、双Value类型和Key-Value类型 2）Action 行动算子：这类算子会触发 SparkContext 提交
sparkRDD操作，转换算子和行动算子
严同学在努力
03-30 502
Spark常用的RDD转换和行动算子
【大数据篇】Spark转换算子（Transformations）和行动算子（Actions）详解
最新发布
林木森的博客
04-10 1703
Apache Spark 提供了大量的算子（操作），这些算子大致可以分为两类：转换算子（Transformations）和行动算子（Actions）。转换算子用于创建一个新的RDD，而行动算子则对RDD进行操作并产生结果。
Spark中的 转换操作、转换算子
Geek白先生的博客
09-09 2026
学习算子推荐的网站：http://homepage.cs.latrobe.edu.au/zhe/ZhenHeSparkRDDAPIExamples.html 转换操作 将当前RDD转换为新的RDD数据集，特点为惰性求值，当触发行动操作时RDD才开始执行计算。 转换算子举例 1.map、flatMap、distinct map说明：将一个RDD中的每个数据项，通过map中的函数映射变为一个新的元素...
RDD的转换（transsformations）和行动（actions）算子
weixin_43442298的博客
08-06 219
1.转换（transsformations）算子 1.1 基础转换算子（18个） map、flatMap、filter、distinct、mapPartitions、mapPartitionsWithIndex、union、intersection(交集运算）、subtract(差集运算)、coalesce、repartition、randomSplit、glom、zip、zipPartitions、zipWithIndex、zipWithUniqueid、sortBy 1.2 键值对转换算子(1.
Spark（三）【SparkCore】- Spark 转换算子、行动算子、持久化算子、代码流程
奥迪的博客
02-07 471
1. Transformations 转换算子 1.1 概念： Transformations 类算子是一类算子（函数）叫做转换算子，如map,flatMap,reduceByKey 等。Transformations 算子是延迟执行，也叫懒加载执行。 1.2 Transformation 类算子： filter 过滤符合条件的记录数，true 保留，false 过滤掉。 map 将一个 RDD 中的每个数据项，通过 map 中的...
【spark使用】3.转换算子
qq_22849251的博客
03-10 1776
map String转为Tuple2<String, Integer> public class test { public static void main(String[] args) { SparkConf conf = new SparkConf().setAppName("jiangtao_demo").setMaster("local"); JavaSparkContext jsc = new JavaSparkContext(conf);
【精通Spark系列】Spark算子大合集，一文掌握spark中的常用转换与行动算子
大数据小禅的博客
01-09 2215
RDD 中的算子从功能上分为两大类1.Transformation(转换算子) 它会在一个已经存在的 RDD 上创建一个新的 RDD，这也使得RDD之间存在了血缘关系与联系2.Action(动作算子) 执行各个分区的计算任务, 结果返回到 Driver 中特点1.Spark 中所有的 Transformations 是 惰性 的, 不会立即执行获得结果. 只会记录在数据集上要应用的操作.当需要返回结果给 Driver 时, 才会执行这些操作, 这个特性叫做 惰性求值。
spark的转换和行动
蕾姆的博客
01-28 666
1. map：是对RDD中的每个元素都执行一个指定的函数来产生一个新的RDD。 任何原RDD中的元素在新RDD中都有且只有一个元素与之对应。 2. filter： 是对RDD中的每个元素都执行一个指定的函数来过滤产生一个新的RDD。 任何原RDD中的元素在新RDD中都有且只有一个元素与之对应。 3. flatMap：与map类似，区别是原RDD中的元素经map处理后只能生成一个元素，而原RDD...
Spark--RDD转换算子&行动算子
小兔子乖乖
09-22 578
RDD算子一.RDD转换算子1）map2）mapPartitions3）mapPartitionsWithIndex 一.RDD转换算子 1）map 将处理的数据逐条进行映射转换，这里的转换可以是类型的转换，也可以是值的转换。 object Spark_rdd_01 { def main(args: Array[String]): Unit = { val conf = new SparkConf().setAppName("RDD").setMaster("local[*]")
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值