Spark之transformation算子

最新推荐文章于 2023-07-23 10:00:00 发布
最新推荐文章于 2023-07-23 10:00:00 发布
阅读量831 收藏 3
点赞数 2
分类专栏： Scala 大数据 文章标签： Scala spark
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42568742/article/details/90320980
版权

1、combineByKey

首先给RDD中每个分区中的每个key一个初始值 其次在RDD每个分区内部 相同的key聚合一次
再次在RDD不同的分区之间将相同的key结果聚合一次

def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local").setAppName("combineByKey")
    val sc = new SparkContext(conf)
    val rdd1: RDD[(String, Int)] = sc.makeRDD(List[(String, Int)](
      ("zhangsan", 10), ("zhangsan", 20), ("wangwu", 30),
      ("lisi", 40), ("zhangsan", 50), ("lisi", 60),
      ("wangwu", 70), ("wangwu", 80), ("lisi", 90)
    ), 3)
    rdd1.mapPartitionsWithIndex((index,iter)=>{
      val arr = ArrayBuffer[(String,Int)]()
      iter.foreach(tp=>{
        arr.append(tp)
        println("rdd1 partition index = "+index+",value = "+tp)
      })
      arr.iterator
    }).count()

    /**
      * 0号分区：("zhangsan", 10), ("zhangsan", 20), ("wangwu", 30)
      * 1号分区：("lisi", 40), ("zhangsan", 50), ("lisi", 60)
      * 2号分区：("wangwu", 70), ("wangwu", 80), ("lisi", 90)
      *
      * 初始化后：
      * 0号分区：("zhangsan", 10hello),("wangwu", 30hello)
      * 1号分区：("lisi", 40hello), ("zhangsan", 50hello)
      * 2号分区：("wangwu", 70hello),("lisi", 90hello)
      *
      * 经过RDD分区内的合并后:
      * 0号分区：("zhangsan", 10hello@20)，("wangwu", 30hello)
      * 1号分区：("lisi", 40hello@60), ("zhangsan", 50hello)
      * 2号分区：("wangwu", 70hello@80),("lisi", 90hello#50hello)
      *
      * 经过RDD分区之间的合并：("zhangsan", 10hello@20#50hello),("lisi",40hello@60#90hello),("wangwu", 30hello#70hello@80)
      */
    //    rdd1.combineByKey((v:Int)=>{v+"hello"},(s:String,v:Int)=>{s+"@"+v},(s1:String,s2:String)=>{s1+"#"+s2})
    val result: RDD[(String, String)] = rdd1.combineByKey(v=>{v+"hello"}, (s:String, v)=>{s+"@"+v}, (s1:String, s2:String)=>{s1+"#"+s2})
    result.foreach(println)
  }

2、aggregateByKey

首先是给定RDD的每个分区一个初始值，然后RDD中每个分区中按照相同的key，结合初始值去合并，最后RDD之间相同的key 聚合。

 def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("aggregateByKey").setMaster("local")
    val sc = new SparkContext(conf)
    val rdd1 = sc.makeRDD(List[(String,Int)](
      ("zhangsan",10),("zhangsan",20),("wangwu",30),
      ("lisi",40),("zhangsan",50),("lisi",60),
      ("wangwu",70),("wangwu",80),("lisi",90)
    ),3)
    rdd1.mapPartitionsWithIndex((index,iter)=>{
        val arr = ArrayBuffer[(String,Int)]()
        iter.foreach(tp=>{
          arr.append(tp)
          println("rdd1 partition index = "+index+",value = "+tp)
        })
       arr.iterator
    }).count()

    /**
      *  0号分区：
      *     ("zhangsan",10)
      *     ("zhangsan",20)
      *     ("wangwu",30)
      *  1号分区：
      *     ("lisi",40)
      *     ("zhangsan",50)
      *     ("lisi",60)
      *  2号分区：
      *     ("wangwu",70)
      *     ("wangwu",80)
      *     ("lisi",90)
      *
      *  init :
      *   0:("zhangsan",hello~10~20),("wangwu",hello~30)
      *   1:("zhangsan",hello~50),("lisi"，hello~40~60)
      *   2:("lisi",hello~90)，("wangwu",hello~70~80)
      *
      *   分区合并后：("zhangsan",hello~10~20#hello~50),("lisi",hello~40~60#hello~90),("wangwu",hello~30#hello~70~80)
      *   ("zhangsan")
      */
    val result: RDD[(String, String)] = rdd1.aggregateByKey("hello")((s, v)=>{s+"~"+v}, (s1, s2)=>{s1+"#"+s2})
    result.foreach(print)
  }

3、coalesce

coalesce(numPartiton,shuffle=false) coalesce 增加或者减少分区，默认没有shuffle
coalesce 如果从少的分区增到多的分区，如果指定没有shuffle,那么不起作用。 coalesce(num,true) =
repartition(num)

 def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
    conf.setMaster("local").setAppName("coalesce")
    val sc = new SparkContext(conf)
    val rdd1: RDD[String] = sc.parallelize(List[String](
      "love1", "love2", "love3", "love4",
      "love5", "love6", "love7", "love8",
      "love9", "love10", "love11", "love12"),3)
    val rdd2 :RDD[String] = rdd1.mapPartitionsWithIndex((index,iter)=>{
      val list = ListBuffer[String]()
      iter.foreach(one=>{
        list.append(s"rdd1 partition = 【$index】,value = 【$one】")
      })
      list.iterator
    },true)

    val rdd3 = rdd2.coalesce(4,false)
    val rdd4 = rdd3.mapPartitionsWithIndex((index,iter)=>{
      val arr = ArrayBuffer[String]()
      iter.foreach(one=>{
        arr.append(s"rdd3 partition = 【$index】,value =  【$one】")
      })
      arr.iterator
    })
    val results : Array[String] = rdd4.collect()
    results.foreach(println)
    sc.stop()
  }

4、cogroup

 def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
    conf.setMaster("local")
    conf.setAppName("cogroup")
    val sc = new SparkContext(conf)
    val rdd1 = sc.parallelize(List[(String,String)](("zhangsan","female"),("zhangsan","female1"),("lisi","male"),("wangwu","female"),("maliu","male")),3)
    val rdd2 = sc.parallelize(List[(String,Int)](("zhangsan",18),("lisi",19),("lisi",190),("wangwu",20),("tianqi",21)),4)
    val resultRDD: RDD[(String, (Iterable[String], Iterable[Int]))] = rdd1.cogroup(rdd2)
    resultRDD.foreach(info=>{
      val key = info._1
      val value1: List[String] = info._2._1.toList
      val value2: List[Int] = info._2._2.toList
      println("key = "+key+",value1 = "+value1+",value2 = "+value2)
    })
    println("resultRDD partitioin length = "+resultRDD.getNumPartitions)
    sc.stop()
  }

5、distinct

distinct 去重，有shuffle产生，内部实际是 map+reduceByKey+map实现

def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
    conf.setMaster("local")
    conf.setAppName("distinct")
    val sc = new SparkContext(conf)
    val infos = sc.parallelize(List[String]("a","a","b","b","c","c","d"),4)
    val result: RDD[String] = infos.distinct()
    result.foreach(println)
    sc.stop()
  }

6、filter

filter 过滤算子，过滤数据，返回true的数据会被留下

def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
    conf.setAppName("filter")
    conf.setMaster("local")
    val sc = new SparkContext(conf)
    val infos = sc.makeRDD(List[Int](1,2,3,4,5))
    val result = infos.filter(one=>{
      one>3
    })
    result.foreach(println)
    sc.stop()
  }

7、flatMap

flatMap 是一对多的关系 处理一条数据得到多条数据结果

 def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
    conf.setAppName("map").setMaster("local")
    val sc = new SparkContext(conf)
    val infos = sc.parallelize(Array[String]("hello spark","hello hdfs","hello bjsxt"))
    val result = infos.flatMap(one=>{
      one.split(" ")
    })
    result.foreach(println)
  }

8、flatMapValues

(K,V) -> (K,V) 作用在K,V格式的RDD上，对一个Key的一个Value返回多个Value

 def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
    conf.setAppName("flatMapValues")
    conf.setMaster("local")
    val sc = new SparkContext(conf)
    val infos: RDD[(String, String)] = sc.makeRDD(List[(String, String)](("zhangsna", "18"), ("lisi", "20"), ("wangwu", "30")))
    val transInfo: RDD[(String, String)] = infos.mapValues(s => {
      s + " " + "zhangsan18"
    })
    val result = transInfo.flatMapValues(s=>{
      s.split(" ")
    })
    result.foreach(print)

    sc.stop()
  }

9、fullOuterJoin
(K,V)格式的RDD和(K,W)格式的RDD 使用fullOuterJoin结合是以两边的RDD出现的key为主，得到（K,(Option(V)，Option(W))）

def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
    conf.setMaster("local")
    conf.setAppName("fullOuterJoin")
    val sc = new SparkContext(conf)
    val nameRDD = sc.parallelize(List[(String,String)](("zhangsan","female"),("lisi","male"),("wangwu","female"),("maliu","male")),3)
    val scoreRDD = sc.parallelize(List[(String,Int)](("zhangsan",18),("lisi",19),("wangwu",20),("tianqi",21)),4)
    val fullOuterJoin: RDD[(String, (Option[String], Option[Int]))] = nameRDD.fullOuterJoin(scoreRDD)
    fullOuterJoin.foreach(println)
    println("fullOuterJoin RDD partition length = "+fullOuterJoin.getNumPartitions)
    sc.stop()
  }

10、groupBy

按照指定的规则，将数据分组

 def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local").setAppName("groupBy")
    val sc = new SparkContext(conf)
    val rdd = sc.parallelize(List[(String,Double)](("zhangsan",66.5),("lisi",33.2),("zhangsan",66.7),("lisi",33.4),("zhangsan",66.8),("wangwu",29.8)))
    val result: RDD[(Boolean, Iterable[(String, Double)])] = rdd.groupBy(one => {
      one._2 > 34
    })
    result.foreach(print)


//    val rdd1: RDD[String] = sc.parallelize(List[String](
//      "love1", "love2", "love3", "love4",
//      "love5", "love6", "love7", "love8",
//      "love9", "love10", "love11", "love12"),3)
//
//    val result: RDD[(String, Iterable[String])] = rdd1.groupBy(one=>{one.split("")(4)})
//    result.foreach(print)
  }

11、groupByKey

根据key 去将相同的key 对应的value合并在一起 （K,V）=>(K,[V])

 def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local").setAppName("groupByKey")
    val sc = new SparkContext(conf)
    val rdd = sc.parallelize(List[(String,Double)](("zhangsan",66.5),("lisi",33.2),("zhangsan",66.7),("lisi",33.4),("zhangsan",66.8),("wangwu",29.8)))
    val rdd1 = rdd.groupByKey()
    rdd1.foreach(info=>{
      val name = info._1
      val value: Iterable[Double] = info._2
      val list: List[Double] = info._2.toList
      print("name = "+name+",list = "+list)
    })
    sc.stop()
  }

12、intersection

intersection 取两个RDD的交集，两个RDD的类型要一致 结果RDD的分区数与父rdd多的一致

def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
    conf.setMaster("local")
    conf.setAppName("intersection")
    val sc = new SparkContext(conf)
    val rdd1 = sc.parallelize(List[String]("zhangsan","lisi","wangwu"),5)
    val rdd2 = sc.parallelize(List[String]("zhangsan","lisi","maliu"),4)
    val intersectionRDD: RDD[String] = rdd1.intersection(rdd2)
    intersectionRDD.foreach(println)
    println("intersectionRDD partition length = "+intersectionRDD.getNumPartitions)
    sc.stop()
  }

13、join

join 会产生shuffle （K,V）格式的RDD和（K,V）格式的RDD按照key相同join
得到（K,(V,W)）格式的数据。

def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
    conf.setAppName("join")
    conf.setMaster("local")
    val sc = new SparkContext(conf)
    val nameRDD = sc.parallelize(List[(String,String)](("zhangsan","female"),("lisi","male"),("wangwu","female")))
    val scoreRDD = sc.parallelize(List[(String,Int)](("zhangsan",18),("lisi",19),("wangwu",20)))
    val joinRDD: RDD[(String, (String, Int))] = nameRDD.join(scoreRDD)
    joinRDD.foreach(println)
  }

14、leftOuterJoin

(K,V)格式的RDD和(K,W)格式的RDD
使用leftOuterJoin结合是以左边的RDD出现的key为主，得到（K,(V,Option(W))）

 def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
    conf.setMaster("local")
    conf.setAppName("leftOuterJoin")
    val sc = new SparkContext(conf)
    val nameRDD = sc.parallelize(List[(String,String)](("zhangsan","female"),("lisi","male"),("wangwu","female"),("maliu","male")))
    val scoreRDD = sc.parallelize(List[(String,Int)](("zhangsan",18),("lisi",19),("wangwu",20),("tianqi",21)))
    val leftOuterJoin: RDD[(String, (String, Option[Int]))] = nameRDD.leftOuterJoin(scoreRDD)
    leftOuterJoin.foreach(println)
    sc.stop()
  }

15、map

处理数据是一对一的关系，进入一条数据处理，出来的还是一条数据

 def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
    conf.setAppName("map").setMaster("local")
    val sc = new SparkContext(conf)
    val infos = sc.parallelize(Array[String]("hello spark","hello hdfs","hello bjsxt"))
    val result = infos.map(one=>{one.split(" ")})
    result.foreach(arr=>{arr.foreach(println)})
    sc.stop()
  }

16、mapPartitions

遍历的是每个分区中的数据，一个个分区的遍历，相对于map 一条条处理数据，性能比较高。

 def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
    conf.setMaster("local")
    conf.setAppName("mapPartitions")
    val sc = new SparkContext(conf)
    val infos = sc.parallelize(List[String]("a","b","c","d","e","f","g"),4)
    val result = infos.mapPartitions(iter=>{
      println("创建数据库连接... ... ")
      val array = ArrayBuffer[String]()
      while(iter.hasNext){
        val s = iter.next()
        println("拼接sql... ... "+s)
        array.append(s)
      }
      println("关闭数据库连接... ... ")
      array.iterator
    })
    result.count()
    sc.stop()
  }

17、mapPartitionsWithIndex

可以拿到每个RDD中的分区，以及分区中的数据

def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
    conf.setMaster("local")
    conf.setAppName("mapPartitionWithIndex")
    val sc = new SparkContext(conf)
    val lines = sc.textFile("./data/words",5)
    val result = lines.mapPartitionsWithIndex((index,iter)=>{
      val arr = ArrayBuffer[String]()
      iter.foreach(one=>{
        arr.append(s"partition = 【$index】,value = $one")
      })
      arr.iterator
    },true)
    result.foreach(println)
    sc.stop()
  }

18、mapValues

针对K,V格式的数据，只对Value做操作，Key保持不变

def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
    conf.setAppName("mapValues")
    conf.setMaster("local")
    val sc = new SparkContext(conf)
    val infos: RDD[(String, String)] = sc.makeRDD(List[(String, String)](("zhangsna", "18"), ("lisi", "20"), ("wangwu", "30")))
    val result: RDD[(String, String)] = infos.mapValues(s => {
      s + " " + "zhangsan18"
    })
    result.foreach(print)
    sc.stop()
  }

19、reduceByKey

首先会根据key 去分组，然后处理每个组，将每个组内的value聚合 作用在K,V格式的RDD上

 def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
    conf.setAppName("reduceByKey")
    conf.setMaster("local")
    val sc = new SparkContext(conf)
    val infos = sc.parallelize(List[(String,Int)](("zhangsan",1),("zhangsan",2),("zhangsan",3),("lisi",100),("lisi",200)))
    val result = infos.reduceByKey((v1,v2)=>{v1+v2})
    result.foreach(println)
    sc.stop()
  }

20、repartition

重新分区，可以将RDD的分区增多或者减少，会产生shuffle coalesce(num,true) = repartition(num)

def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local").setAppName("repartition")
    val sc = new SparkContext(conf)
    val rdd1: RDD[String] = sc.parallelize(List[String](
      "love1", "love2", "love3", "love4",
      "love5", "love6", "love7", "love8",
      "love9", "love10", "love11", "love12"),3)
    val rdd2 :RDD[String] = rdd1.mapPartitionsWithIndex((index,iter)=>{
      val list = ListBuffer[String]()
      iter.foreach(one=>{
        list.append(s"rdd1 partition = 【$index】,value = 【$one】")
      })
      list.iterator
    },true)

//    val rdd3 = rdd2.repartition(4)
    val rdd3 = rdd2.repartition(3)
    val rdd4 = rdd3.mapPartitionsWithIndex((index,iter)=>{
      val arr = ArrayBuffer[String]()
      iter.foreach(one=>{
        arr.append(s"rdd3 partition = 【$index】,value =  【$one】")
      })
      arr.iterator
    })
    val results : Array[String] = rdd4.collect()
    results.foreach(println)
    sc.stop()
  }

21、rightOuterJoin

(K,V)格式的RDD和(K,W)格式的RDD
使用rightOuterJoin结合是以右边的RDD出现的key为主，得到（K,(Option(V)，W)）

def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
    conf.setMaster("local")
    conf.setAppName("rightOuterJoin")
    val sc = new SparkContext(conf)
    val nameRDD = sc.parallelize(List[(String,String)](("zhangsan","female"),("lisi","male"),("wangwu","female"),("maliu","male")),3)
    val scoreRDD = sc.parallelize(List[(String,Int)](("zhangsan",18),("lisi",19),("wangwu",20),("tianqi",21)),4)
    val rightOuterJoin: RDD[(String, (Option[String], Int))] = nameRDD.rightOuterJoin(scoreRDD)
    rightOuterJoin.foreach(println)
    println("rightOuterJoin RDD partition length = "+rightOuterJoin.getNumPartitions)
    sc.stop()
  }

22、sample

sample随机抽样，参数sample(有无放回抽样，抽样的比例，种子)
有种子和无种子的区别：
有种子是只要针对数据源一样，都是指定相同的参数，那么每次抽样到的数据都是一样的
没有种子是针对同一个数据源，每次抽样都是随机抽样

 def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
    conf.setAppName("sample")
    conf.setMaster("local")
    val sc = new SparkContext(conf)
    val lines = sc.textFile("./data/sampleData.txt")
    val result = lines.sample(true,0.01,100)
    result.foreach(println)
    sc.stop()
  }

23、sortBy

  sortBy 排序，参数中指定按照什么规则去排序，第二个参数 true/false 指定升序或者降序
   无需作用在K,V格式的RDD上

def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
    conf.setAppName("sortBy")
    conf.setMaster("local")
    val sc = new SparkContext(conf)
    val infos = sc.parallelize(Array[(String,String)](("f","f"),("a","a"),("c","c"),("b","b")))
    val result = infos.sortBy(tp=>{
      tp._1
    },false)
    result.foreach(println)

    val infos1 = sc.parallelize(Array[Int](400,200,500,100,300))
    val result1 = infos1.sortBy(one=>{one/100},false)
    result1.foreach(println)
    sc.stop()
  }

24、sortByKey

sortByKey 默认按照key去排序，作用在K,V格式的RDD上

 def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
    conf.setAppName("sortByKey")
    conf.setMaster("local")
    val sc = new SparkContext(conf)
    val infos = sc.parallelize(Array[(String,String)](("f","f"),("a","a"),("c","c"),("b","b")))
    val result = infos.sortByKey(false)
    result.foreach(println)
    sc.stop()
  }

25、subtract

 subtract 取RDD的差集
 subtract两个RDD的类型要一致，结果RDD的分区数与subtract算子前面的RDD的分区个数一致

def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
    conf.setMaster("local")
    conf.setAppName("subtract")
    val sc = new SparkContext(conf)
    val rdd1 = sc.parallelize(List[String]("zhangsan","lisi","wangwu"),5)
    val rdd2 = sc.parallelize(List[String]("zhangsan","lisi","maliu"),4)
    val subtractRDD: RDD[String] = rdd1.subtract(rdd2)
    subtractRDD.foreach(println)
    println("subtractRDD partition length = "+subtractRDD.getNumPartitions)
    sc.stop()
  }

26、union

union 合并RDD ，两个RDD必须是同种类型，不必要是K,V格式的RDD

def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
    conf.setMaster("local")
    conf.setAppName("union")
    val sc = new SparkContext(conf)
    val rdd1 = sc.parallelize(List[String]("zhangsan","lisi","wangwu","maliu"),3)
    val rdd2 = sc.parallelize(List[String]("a","b","c","d"),4)
    val unionRDD: RDD[String] = rdd1.union(rdd2)
    unionRDD.foreach(println)
    println("unionRDD partitioin length = "+unionRDD.getNumPartitions)
    sc.stop()
  }

27、zip

将两个RDD 合成一个K,V格式的RDD,分区数要相同，每个分区中的元素必须相同

def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local").setAppName("zip")
    val sc = new SparkContext(conf)
    val rdd1 = sc.parallelize(List[String]("a","b","c"),2)
    val rdd2 = sc.parallelize(List[Int](1,2,3),numSlices = 2)

    val result: RDD[(String, Int)] = rdd1.zip(rdd2)
    result.foreach(print)
  }

28、zipWithIndex

将RDD和数据下标压缩成一个K,V格式的RDD

 def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local").setAppName("zip")
    val sc = new SparkContext(conf)
    val rdd1 = sc.parallelize(List[String]("a","b","c"),2)
    val rdd2 = sc.parallelize(List[Int](1,2,3),numSlices = 2)
    val result: RDD[(String, Long)] = rdd1.zipWithIndex()
    result.foreach(print)
  }
三岁会演戏
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
大数据｜Spark介绍
因为健忘，所以记点有的没的〒▽〒
05-18 7525
park为了解决以往分布式计算框架存在的一些问题(重复计算、资源共享、系统组合)，提出了一个分布式数据集的抽象数据模型：RDD(Resilient Distributed Datasets)弹性分布式数据集。
Spark-Transformation和Action算子.md
最新发布
08-09
Spark_Transformation和Action算子.md
[spark]transformation算子
胖胖的博客
10-26 726
rdd1.cogroup(rdd2):将rdd1和rdd2按照他们相同的key进行分组，返回key,rdd1的value,rdd2的value组成的元组，在这个元组中._1是key，._2是(value1,value2)，其中rdd1的value，rdd2的value都是迭代器，是相同key对应的值组成的迭代器。参数numPartitions：指结果RDD的分区个数，也可以不写参数，默认是和父RDD一样的分区数，返回值是一个元组，第一个值是key的值，第二个值是该key进行分组的value组成的迭代器。
spark算子--transformation篇
zhaolimin6666的专栏
02-22 637
spark算子分为两大种，一种是transformation算子，另一种是action算子。其实细分的话transformation算子又可以细分为value型和k-v型，个人感觉没必要，也就不细化了，省得把大家搞晕。 transformation又叫转换算子，它从一个RDD到另一个RDD是延迟执行的，不会马上触发作业的提交，只有在后续遇到某个action算子时才执...
Spark简介以及最详细安装教程
热门推荐
zp17834994071的博客
07-29 2万+
首先来聊聊什么是Spark?为什么现在那么多人都用Spark? Spark简介： Spark是一种通用的大数据计算框架,是基于**RDD（弹性分布式数据集）**的一种计算模型。那到底是什么呢？可能很多人还不是太理解，通俗讲就是可以分布式处理大量集数据的，将大量集数据先拆分，分别进行计算，然后再将计算后的结果进行合并。 为什么使用Spark ...
Spark详解
qq_40322236的博客
02-06 5938
Spark 是一种基于内存的快速、通用、可扩展的大数据分析计算引擎。在之前的学习中，Hadoop的 MapReduce 是大家广为熟知的计算框架，那为什么咱们还要学习新的计算框架 Spark 呢，这里就不得不提到 Spark 和 Hadoop 的关系。
Spark常用的算子以及Scala函数总结.pdf
05-17
Spark RDD 算子说明，分别讲述了Transformation和Action这两类的算子。
Spark Transformation和Action算子速查表.pdf
05-17
spark transformation & action 算子速查表，大数据实时和离线数据处理方向，希望对大家学习和工作有所帮助。
spark算子基础讲义1
03-13
关于spark较为简单的算子讲义 和相对的用法，基于scala语言
transformation、action算子代码示例
10-13
适合新手练习，大数据的核心内容Spark Core算子操作。
大数据学习 之 Spark 概述
阳光大男孩！！！的博客
08-31 7026
Spark简介 Spark 是一种由 Scala 语言开发的快速、通用、可扩展的大数据分析引擎。 Spark主要由五部分组成： Spark Core Spark Core 中提供了 Spark 最基础与最核心的功能，Spark 其他的功能如：Spark SQL， Spark Streaming，GraphX, MLlib 都是在 Spark Core 的基础上进行扩展的 Spark SQL Spark SQL 是 Spark 用来操作结构化数据的组件。通过 Spark SQL，用户可以使用 SQL 或者
Spark入门教程（非常详细）从零基础入门到精通，看完这一篇就够了
Javachichi的博客
07-23 1万+
Hive 是将 SQL 转为 MapReduce。SparkSQL 可以理解成是将 SQL 解析成：“RDD + 优化” 再执行在学习Spark SQL前，需要了解数据分类。
Spark简介
m0_56719462的博客
05-09 3451
同时，Spark 还可以与多种存储系统和数据源集成，并提供了丰富的语言接口和集群管理器集成，以满足不同的数据处理和分析需求。此外，Spark 还提供了丰富的机器学习和图处理库，以支持大规模数据集的机器学习和图处理任务。此外，Spark 对于 PB 级别的数据处理能力不如 Hadoop，但是 Spark 可以与其他存储系统集成，以支持更大规模的数据处理。Spark MLlib：Spark 的机器学习库，它提供了一系列机器学习算法，以支持大规模数据集的机器学习任务。
Spark（四）—— Transformation算子
分享AI工具、AI技术、AI学习经验，感谢大家关注
03-12 897
文章目录Transformation算子基本算子1. map(func)2. filter(func)3. flatMap4. 集合运算（union、intersection、distinct）5. 分组（groupByKey、reduceByKey、cogroup）6. 排序（sortBy、sortByKey）高级算子1. mapPartitionsWithIndex(func)2. aggre...
（一）spark是什么？
一智哇的博客
10-29 1万+
1.spark是什么？ spark是一个用来实现快速，通用的集群计算平台 spark适用于各种各样原先需要多种不同的分布式平台的场景，包括批处理，迭代算法，交互式查询，流处理。通过在一个统一的框架下支持这些不同的计算，spark使我们可以简单而低耗地把各种处理流程整合在一起。 2.spark的用途 （1）：数据科学任务 具备 SQL、统计、预测建模（机器学习）等方面的经验，以及一定的python，matlab，R语言能力的数据科学家对数据进行分析，以回答问题或发现一些潜在规律。 （2）：数据处理任务
大数据Spark框架概述
赵广陆
05-04 4995
目录1 Spark 是什么2 Spark 四大特点2.1 速度快2.2 易于使用2.3 通用性强2.4 运行方式3 Spark 框架模块3.1 Spark Core3.2 Spark SQL3.3 Spark Streaming3.4 Spark MLlib3.5 Spark GraphX3.6 Structured Streaming4 Spark 运行模式 1 Spark 是什么 Spark 是加州大学伯克利分校AMP实验室（Algorithms Machines and People Lab）开发的
09.大数据技术之Spark
wzb1983的博客
07-13 8309
Spark是一种快速、通用、可扩展的大数据分析引擎，2009年诞生于加州大学伯克利分校AMPLab，2010年开源，2013年6月成为Apache孵化项目，2014年2月成为Apache顶级项目。项目是用Scala进行编写。 目前，Spark生态系统已经发展成为一个包含多个子项目的集合，其中包含SparkCore、SparkSQL、Spark Streaming、GraphX、MLib、SparkR等子项目，Spark是基于内存计算的大数据并行计算框架。除了扩展了广泛使用的 MapReduce 计算模型，而
spark的transformation算子
03-16
Spark的transformation算子是指对RDD进行转换操作的函数，它们不会立即执行，而是返回一个新的RDD。常见的transformation算子包括map、filter、flatMap、union、distinct、groupByKey、reduceByKey、sortByKey等。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值