Spark RDD

最新推荐文章于 2024-07-17 09:49:29 发布
最新推荐文章于 2024-07-17 09:49:29 发布
阅读量303 收藏 5
点赞数
分类专栏： Spark 文章标签： Spark  Spark RDD Spark RDD变换 Spark RDD Action
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mao502010435/article/details/89712570
版权

RDD : Resilient Distributed Dataset,弹性分布式数据集

    是spark的基本数据结构，是不可变数据集。RDD中的数据集进行逻辑分区，每个分区可以单独在集群节点进行计算。可以包含任何java,scala，python和自定义类型。

    RDD是只读的记录分区集合。RDD具有容错机制。

    创建RDD方式，一、并行化一个现有集合。

    hadoop 花费90%时间用户rw。
    
    内存处理计算。在job间进行数据共享。内存的IO速率高于网络和disk的10 ~ 100之间。

 

    内部包含5个主要属性
    1.分区列表
    2.针对每个split的计算函数。
    3.对其他rdd的依赖列表
    4.可选，如果是KeyValueRDD的话，可以带分区类。
    5.可选，首选块位置列表(hdfs block location);

默认并发度
local.backend.defaultParallelism() = scheduler.conf.getInt("spark.default.parallelism", totalCores)
taskScheduler.defaultParallelism = backend.defaultParallelism()
sc.defaultParallelism =...; taskScheduler.defaultParallelism
defaultMinPartitions = math.min(defaultParallelism, 2)
sc.textFile(path,defaultMinPartitions)            //1,2

RDD变换

返回指向新rdd的指针，在rdd之间创建依赖关系。每个rdd都有计算函数和指向父RDD的指针。

map()                                    //对每个元素进行变换，应用变换函数
                                            //(T)=>V

 flatMap()                                //压扁,T => TraversableOnce[U]

 reduceByKey(*)                            //按key聚合。 

 val conf = new SparkConf()
        conf.setAppName("WordCountScala")
        conf.setMaster("local[4]") ;
        val sc = new SparkContext(conf)

        val rdd1 = sc.textFile("d:/scala/test.txt",4)
        val rdd2 = rdd1.flatMap(_.split(" ")) ;
        //val rdd3 = rdd2.map(word=>{println("start") ;val t = (word,1) ;println(t + " : end") ; t})
        val rdd3 = rdd2.mapPartitions(it=>{
            import scala.collection.mutable.ArrayBuffer ;
            val buf = ArrayBuffer[String]()
            val tname = Thread.currentThread().getName
            println(tname + " : mapPartitions start ");
            for (e <- it) {
                buf.+=("_" + e);
            }
            buf.iterator
        });
            val rdd5 = rdd3.map(word=>{
            val tname = Thread.currentThread().getName
            println(tname + " : map " + word);
            (word,1)});
            val rdd4 = rdd5.reduceByKey(_ + _)
            val r = rdd4.collect()
            r.foreach(println)
}

    mapPartitions()                            //对每个分区进行应用变换，输入的Iterator,返回新的迭代器，可以对分区进行函数处理。
                                            //Iterator<T> => Iterator<U>

    mapPartitionsWithIndex(func)            //同上，(Int, Iterator<T>) => Iterator<U>

def main(args: Array[String]): Unit = {
        val conf = new SparkConf()
        conf.setAppName("WordCountScala")
        conf.setMaster("local[4]") ;
        val sc = new SparkContext(conf)

        val rdd1 = sc.textFile("d:/scala/test.txt",4)
        val rdd2 = rdd1.flatMap(_.split(" ")) ;

        val rdd3 = rdd2.mapPartitionsWithIndex((index,it) => {
            import scala.collection.mutable.ArrayBuffer;
            val buf = ArrayBuffer[String]()
            val tname = Thread.currentThread().getName
            println(tname + " : " + index + " : mapPartitions start ");
            for (e <- it) {
                buf.+=("_" + e);
            }
            buf.iterator
        });

        val rdd5 = rdd3.map(word=>{
            val tname = Thread.currentThread().getName
            println(tname + " : map " + word);
            (word,1)});
        val rdd4 = rdd5.reduceByKey(_ + _)
        val r = rdd4.collect()
        r.foreach(println)
    }

    filter()                                //过滤器,(T)=>Boolean

//统计hello的个数
  def wordCount3(args: Array[String]): Unit ={
    val conf = new SparkConf();
    //        conf.setAppName("wc");
    //        conf.setMaster("local");
    val sc = new SparkContext(conf);
    val r = sc.textFile(args(0)).flatMap(line=>line.split(" ")).filter(_.equals("hello")).map((_,1)).reduceByKey(_ + _).collect();
    r.foreach(println);
  }

       sample(withReplacement, fraction, seed)    //采样返回采样的RDD子集。
                                            //withReplacement 元素是否可以多次采样.
                                            //fraction : 期望采样数量.[0,1]

def main(args: Array[String]): Unit = {
        val conf = new SparkConf()
        conf.setAppName("WordCountScala")
        conf.setMaster("local[4]") ;
        val sc = new SparkContext(conf)
        val rdd1 = sc.textFile("d:/scala/test.txt",4)
        val rdd2 = rdd1.flatMap(_.split(" "))

        val rdd3 = rdd2.sample(false,0.5)
        rdd3.collect().foreach(println)

    }

    union()                            //类似于mysql union操作。
                                            //select * from persons where id < 10 
                                            //union select * from id persons where id > 29 ;

    def main(args: Array[String]): Unit = {
        val conf = new SparkConf()
        conf.setAppName("WordCountScala")
        conf.setMaster("local[4]") ;
        val sc = new SparkContext(conf)
        val rdd1 = sc.textFile("d:/scala/log.txt",4)
        //所有error
        val errorRDD = rdd1.filter(_.toLowerCase.contains("error"))

        //所有warn行
        val warnRDD = rdd1.filter(_.toLowerCase.contains("warn"));

        val allRDD = errorRDD.union(warnRDD);

        allRDD.collect().foreach(println)
    }

    intersection                            //交集,提取两个rdd中都含有的元素。

def main(args: Array[String]): Unit = {
        val conf = new SparkConf()
        conf.setAppName("WordCountScala")
        conf.setMaster("local[4]") ;
        val sc = new SparkContext(conf)
        val rdd1 = sc.textFile("d:/scala/log.txt",4)
        //所有error
        val errorRDD = rdd1.filter(_.toLowerCase.contains("error"))

        //所有warn行
        val warnRDD = rdd1.filter(_.toLowerCase.contains("warn"));

        val intersecRDD = errorRDD.intersection(warnRDD);

        intersecRDD.collect().foreach(println)

    }

    distinct([numTasks]))                    //去重,去除重复的元素。

def main(args: Array[String]): Unit = {
        val conf = new SparkConf()
        conf.setAppName("WordCountScala")
        conf.setMaster("local[4]") ;
        val sc = new SparkContext(conf)
        val rdd1 = sc.textFile("d:/scala/log.txt",4)
        val rdd2 = rdd1.flatMap(_.split(" "))
        val rdd3 = rdd2.distinct()

        rdd3.collect().foreach(println)
}

    groupByKey()                            //(K,V) => (K,Iterable<V>)

    def main(args: Array[String]): Unit = {
        val conf = new SparkConf()
        conf.setAppName("WordCountScala")
        conf.setMaster("local[4]") ;
        val sc = new SparkContext(conf)
        val rdd1 = sc.textFile("d:/scala/stus.txt",4)
        val rdd2 = rdd1.map(line=>{
            val key = line.split(" ")(3)
            (key,line)
        })
        val rdd3 = rdd2.groupByKey()
        rdd3.collect().foreach(t=>{
            val key = t._1;
            println(key + " : ====================")
            for (e <- t._2){
                println(e)
            }
        })
    }

    aggregateByKey(zeroValue)(seqOp, combOp, [numTasks])                                            //按照key进行聚合
                                                                                                                                                     key:String U:Int = 0

 def main(args: Array[String]): Unit = {
        val conf = new SparkConf()
        conf.setAppName("WordCountScala")
        conf.setMaster("local[4]") ;
        val sc = new SparkContext(conf)
        val rdd1 = sc.textFile("d:/scala/stus.txt",4)
        val rdd2 = rdd1.flatMap(_.split(" "))
        val rdd3 = rdd2.map((_,1))

        def seq(a: Int, b: Int): Int = {
            math.max(a, b)
        }

        def comb(a: Int, b: Int): Int = {
            a + b
        }
        rdd3.aggregateByKey(3)(seq, (a:Int,b:Int)=>{
            a + b
        })
    }

    sortByKey                                //排序

    join(otherDataset, [numTasks])            //连接,(K,V).join(K,W) =>(K,(V,W)) 

    def main(args: Array[String]): Unit = {
        val conf = new SparkConf()
        conf.setAppName("WordCountScala")
        conf.setMaster("local[4]") ;
        //名单
        val sc = new SparkContext(conf)
        val namesRDD1 = sc.textFile("d:/scala/names.txt");
        val namesRDD2 = namesRDD1.map(line=>{
            var arr = line.split(" ")
            (arr(0).toInt,arr(1))
        })
        //总成绩
        val scoreRDD1 = sc.textFile("d:/scala/scores.txt");
        val scoreRDD2 = scoreRDD1.map(line => {
            var arr = line.split(" ")
            (arr(0).toInt, arr(1).toInt)
        })

        val rdd = namesRDD2.join(scoreRDD2)
        rdd.collect().foreach(t=>{
            println(t._1 + " : " + t._2)
        })
    }

    cogroup                                    //协分组
                                            //(K,V).cogroup(K,W) =>(K,(Iterable<V>,Iterable<!-- <W> -->)) 

def main(args: Array[String]): Unit = {
        val conf = new SparkConf()
        conf.setAppName("WordCountScala")
        conf.setMaster("local[4]") ;
        val sc = new SparkContext(conf)
        val rdd1 = sc.textFile("d:/scala/cogroup-1.txt",4)
        //K,V
        val rdd2 = rdd1.map(line=>{
            val arr = line.split(" ")
            (arr(0),arr(1))
        })

        //K,W
        val rdd3 = sc.textFile("d:/scala/cogroup-2.txt", 4)
        //key,value
        val rdd4 = rdd3.map(line => {
            val arr = line.split(" ")
            (arr(0), arr(1))
        })

        val rdd = rdd2.cogroup(rdd4)
        rdd.collect().foreach(t=>{
            println(t._1 + ":=================")
            for( e <- t._2._1){
                println(e)
            }
            for (e <- t._2._2) {
                println(e)
            }
        })
    }


    cartesian(otherDataset)                    //笛卡尔积,RR[T] RDD[U] => RDD[(T,U)]

    def main(args: Array[String]): Unit = {
        val conf = new SparkConf()
        conf.setAppName("WordCountScala")
        conf.setMaster("local[4]") ;
        val sc = new SparkContext(conf)
        val rdd1 = sc.parallelize(Array("tom","tomas","tomasle","tomson"))
        val rdd2 = sc.parallelize(Array("1234","3456","5678","7890"))

        val rdd = rdd1.cartesian(rdd2);
        rdd.collect().foreach(t=>println(t))
    }

    pipe                                    //将rdd的元素传递给脚本或者命令，执行结果返回形成新的RDD（在linux可用）

    def main(args: Array[String]): Unit = {
        val conf = new SparkConf()
        conf.setAppName("WordCountScala")
        conf.setMaster("local[4]") ;

        val sc = new SparkContext(conf)
        val rdd = sc.parallelize(Array("file:///d:","file:///e:","file:///f:",3))
        val rdd0 = rdd.pipe("ls ")
        rdd0.collect().foreach(println)
    }

    coalesce(numPartitions)                    //减少分区
    repartition                                //可增可减

    def main(args: Array[String]): Unit = {
        val conf = new SparkConf()
        conf.setAppName("WordCountScala")
        conf.setMaster("local[8]") ;
        val sc = new SparkContext(conf)

        val rdd1 = sc.textFile("d:/scala/test.txt",4)
        println("rdd1' parti : " + rdd1.partitions.length)

        //降低分区
        val rdd11 = rdd1.coalesce(5);

        //再分区,可憎可减
        val rdd111 = rdd11.repartition(5)

        val rdd2 = rdd111.flatMap(_.split(" "))
        println("rdd2' parti : " + rdd2.partitions.length)

        //
        val rdd3 = rdd2.map((_,1))
        println("rdd3' parti : " + rdd3.partitions.length)
    }

    repartitionAndSortWithinPartitions(partitioner)                   //再分区并在分区内进行排序

RDD Action


    collect()                                //收集rdd元素形成数组.
    count()                                  //统计rdd元素的个数
    reduce()                                //聚合,返回一个值。
    first                                        //取出第一个元素take(1)
    take                                       //提取前三个
    takeSample (withReplacement,num, [seed])
    takeOrdered(n, [ordering])    

    def main(args: Array[String]): Unit = {
        val conf = new SparkConf()
        conf.setAppName("WordCountScala")
        conf.setMaster("local[8]") ;
        val sc = new SparkContext(conf)

        val rdd1 = sc.textFile("d:/scala/test.txt",4)
        //println(rdd1.first())
        rdd1.take(3).foreach(println)
    }

    saveAsTextFile(path)                    //保存到文件
    saveAsSequenceFile(path)                //保存成序列文件

    saveAsObjectFile(path) (Java and Scala)

    countByKey()    

数据倾斜问题：

//重写key,多次组合
def main(args: Array[String]): Unit = {
        val conf = new SparkConf()
        conf.setAppName("WordCountScala")
        conf.setMaster("local[4]") ;
        val sc = new SparkContext(conf)
        val rdd1 = sc.textFile("d:/scala/test.txt",4)
        rdd1.flatMap(_.split(" ")).map((_,1)).map(t=>{
            val word = t._1
            val r = Random.nextInt(100)
            (word + "_" + r,1)
        }).reduceByKey(_ + _,4).map(t=>{
            val word = t._1;
            val count = t._2;
            val w = word.split("_")(0)
            (w,count)
        }).reduceByKey(_ + _,4).saveAsTextFile("d:/scala/out/lean");
    }

 

一只小菜鸟(*￣︶￣)
关注
专栏目录
Spark RDD简介与操作
weixin_62121679的博客
08-01 502
在Spark中，RDD可以看作是一个对象，它本身运行于内存中，如读文件是一个RDD，对文件计算是一个RDD，结果集也是一个RDD。在Spark中，RDD可以看作是一个对象，它本身运行于内存中，可以用于读文件、对文件计算、结果集等操作。在Spark中，RDD是一个并行集合，它包含多个分片，每个分片可以在不同的计算节点上并行处理。然后，我们对RDD进行转换和计算操作，并输出结果。在Scala中，Spark的RDD API提供了许多转换操作（transformations），用于对RDD进行转换和计算。
Spark RDD详解
热门推荐
节至
05-13 1万+
1、RDD是什么RDD：Spark的核心概念是RDD (resilientdistributed dataset)，指的是一个只读的，可分区的分布式数据集，这个数据集的全部或部分可以缓存在内存中，在多次计算间重用。RDD的描述 Internally, each RDD is characterized by five main properties:A list of partitions A fu
Spark 教程 - Hadoop vs Spark vs Flink大数据框架
最新发布
虫虫的博客
07-17 240
Spark 教程 - Hadoop vs Spark vs Flink大数据框架
Spark----RDD（弹性分布式数据集）
Maverick_曲流觞的博客
04-20 2250
RDD，RDD是什么？为么需要RDD？，RDD的五大属性，WordCount中的RDD的五大属性，如何创建RDD？RDD的操作，基本算子/操作/方法/API，分区操作，重分区操作，聚合操作，四个有key函数的`区别`，关联操作，排序操作，RDD的缓存/持久化，cache和persist，checkpoint检查点，共享变量，Shuffle本质
Spark---RDD介绍
weixin_47109902的博客
01-03 1978
RDD（Resilient Distributed Dataset）叫做弹性分布式数据集，是 Spark 中最基本的数据处理模型。代码中是一个抽象类，它代表一个弹性的、不可变、可分区、里面的元素可并行计算的集合。简单的来说，RDD在程序中就是一个包含数据和逻辑的抽象类。RDD是一个最小计算单元。
hbase-rdd：Spark RDD从HBase读取，写入和删除
02-05
要将 Spark 与 HBase 集成，我们需要使用 `hbase-rdd` 库，它提供了 Spark 和 HBase 之间的桥梁。这个库允许我们将 HBase 表作为 RDD 处理，并且支持将 RDD 写回到 HBase。 1. **配置 Spark 与 HBase 连接** 在...
电影评分数据汇总（使用spark2.4+scala, 分析采用spark RDD的API. 数据集采用标准电影评分数据）.zip
03-27
【资源说明】 1、该资源内项目代码都是经过测试运行成功，功能正常的情况下才上传的，请放心下载使用。...电影评分数据汇总,（使用spark2.4+scala完成, 分析采用spark RDD的API. 数据集采用标准电影评分数据）.zip
sparkRDD函数大全
02-28
spark rdd函数大全。spark rdd操作为core操作，虽然后续版本主要以dataset来操作，但是rdd操作也是不可忽略的一部分。
spark RDD
Inkbamboo专栏
12-14 713
声明： 该文档根据spark工程师qq群（511947673）中提供的rdd-api.pdf文档中rdd顺序，进行了一系列的测试。 部分不详细的rdd/transform参考： http://homepage.cs.latrobe.edu.au/zhe/ZhenHeSparkRDDAPIExamples.html。该文档很详细地归纳了rdd，也包含完全的例子。 建议：学习过程中不懂
Spark-RDD
风千里的博客
09-25 446
RDD的概述 俯视整个Spark程序，所有Spark的Application都包含一个Driver程序，该程序是用户的主函数以及在集群中执行各种各样的并行操作。Spark中提出了一个核心的概念 resilient distributed dataset 简称 RDD，RDD是一个并行的分布式集合 ，该集合数据可以跨节点存储，所有的RDD操作都是在集群的计算节点中并行的执行。RDD可以直接通过Had...
Spark 系列（三）—— 弹性式数据集RDDs
weixin_30491641的博客
08-08 114
一、RDD简介 RDD 全称为 Resilient Distributed Datasets，是 Spark 最基本的数据抽象，它是只读的、分区记录的集合，支持并行操作，可以由外部数据集或其他 RDD 转换而来，它具有以下特性： 一个 RDD 由一个或者多个分区（Partitions）组成。对于 RDD 来说，每个分区会被一个计算任务所处理，用户可以在创建 RDD 时指定其分区个数，...
Spark RDD（弹性分布式数据集）
weixin_47243236的博客
12-09 876
1. RDD 1.1 RDD 是什么 RDD（Resilient Distributed Dataset）：弹性分布式数据集，是 Spark 对数据集的抽象，代表一个只读、不可变、可分区、其中元素可进行并行计算的集合，并且是可跨越集群节点进行并行操作的有容错机制的集合。 RDD 是通过 Hadoop 文件系统（HDFS）中文件或者驱动程序中现有的 Scala 集合开始，然后对其进行转换来创建的。 1.2 RDD 特性 A list of partitions RDD 是一个包含多个分区的列表
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值