spark(一)--spark-core--RDD入门实战(详解各大api,基于IDEA开发)

最新推荐文章于 2023-11-01 15:56:32 发布

zisuu

最新推荐文章于 2023-11-01 15:56:32 发布

阅读量1.1k

点赞数 1

文章标签： spark IDEA RDD HADOOP spark-core

本文链接：https://blog.csdn.net/zisuu/article/details/106193879

版权

spark 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

本文深入解析Apache Spark中RDD的概念、创建方式及转换操作，包括map、flatMap、reduceByKey等核心函数，通过实例演示如何利用RDD进行大数据处理，适合Spark初学者及开发者进阶学习。

摘要由CSDN通过智能技术生成

前言

spark系列教程

spark-core—RDD进阶知识(图文详解,基于IDEA开发)

本篇文章操作基于IDEA的本地测试,如果你还不会如何在IDEA中运行spark,请参考这篇文章

IDEA开发第一个spark程序

先说说这篇文章说了什么,

如果你对spark有所了解,应该知道spark的几大内置模块:
在这里插入图片描述
这篇文章就是基于IDEA,详解spark-Core(围绕RDD展开)
即:

RDD创造操作
RDD转化操作
RDD行为操作

0. 入门经典程序,统计字符

在项目的父目录下创建in目录,创建word.txt
看不懂?没关系,先把后面看懂了,再回来看这个

  def main(args: Array[String]): Unit = {
    //上下文
    var conf=new SparkConf().setAppName("WordCount").setMaster("local");
    var sc=new SparkContext(conf);
    sc.setLogLevel("ERROR")

    //1.读取文件,将文件内容一行一行读取
    var lines:RDD[String] =  sc.textFile("in/word.txt");
    //2将一行一行数据分解成一个个单词
     var words:RDD[String]=lines.flatMap(_.split(" "));
    //3.将单词数据进行结构转化,便于统计
    var wordToOne=words.map((_,1));
    //4.两两聚合
   var sum=wordToOne.reduceByKey(_+_)
    //5打印
    var result=sum.collect();
    result.foreach(println);
  }

图解:
![在这里插入图片描述](https://img-blog.csdnimg.cn/20200518153250598.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppc3V1,size_16,color_FFFFFF,t_70

1. RDD

rdd简介
通俗点来讲，可以将 RDD 理解为一个分布式对象集合，本质上是一个只读的分区记录集合。每个 RDD 可以分成多个分区，每个分区就是一个数据集片段。一个 RDD 的不同分区可以保存到集群中的不同结点上，从而可以在集群中的不同结点上进行并行计算。
在这里插入图片描述

RDD 实质上是一种更为通用的迭代并行计算框架，用户可以显示控制计算的中间结果，然后将其自由运用于之后的计算。

在大数据实际应用开发中存在许多迭代算法，如机器学习、图算法等，和交互式数据挖掘工具。这些应用场景的共同之处是在不同计算阶段之间会重用中间结果，即一个阶段的输出结果会作为下一个阶段的输入。

RDD 正是为了满足这种需求而设计的。虽然 MapReduce 具有自动容错、负载平衡和可拓展性的优点，但是其最大的缺点是采用非循环式的数据流模型，使得在迭代计算时要进行大量的磁盘 I/O 操作。

通过使用 RDD，用户不必担心底层数据的分布式特性，只需要将具体的应用逻辑表达为一系列转换处理，就可以实现管道化，从而避免了中间结果的存储，大大降低了数据复制、磁盘 I/O 和数据序列化的开销。

2.RDD- 创建操作

从集合中创建
1）使用parallelize()从集合创建
val rdd = sc.parallelize(Array(1,2,3,4,5,6,7,8))
2）使用makeRDD()从集合创建
val rdd1 = sc.makeRDD(Array(1,2,3,4,5,6,7,8))

  def main(args: Array[String]): Unit = {
    //上下文
    var conf=new SparkConf().setAppName("WordCount").setMaster("local");
    var sc=new SparkContext(conf);
    sc.setLogLevel("ERROR")

    //1.使用makeRDD创建
    var r1=sc.makeRDD(Array(1,2,3,4,5,6));
    r1.collect().foreach(println);

    //2.使用parallelize创建
    var r2=sc.parallelize(Array(1,2,3,4,5,6));
    r2.collect().foreach(println);
  }

从外部创建
包括本地的文件系统，还有所有Hadoop支持的数据集，比如HDFS、Cassandra、HBase等，
如前面写过的----var lines:RDD[String] = sc.textFile(“in/word.txt”);

3. 转换操作–value类型

注:下划线表示自身
若出现x._1,x._2,则x表示key-value键值对

1 map算子

作用：返回一个新的RDD，该RDD由每一个输入元素经过func函数转换后组成
需求：创建一个1-10数组的RDD，将所有元素*2形成新的RDD

 def main(args: Array[String]): Unit = {
    //上下文
    var conf=new SparkConf().setAppName("WordCount").setMaster("local");
    var sc=new SparkContext(conf);
    sc.setLogLevel("ERROR")

    //创建
    var arr=sc.makeRDD(1 to 10);
    var map=arr.map(_*2);
    //打印
    map.collect().foreach(println);
  }

2 mapPartitions(func) 算子

作用：类似于map，但独立地在RDD的每一个分片上运行，因此在类型为T的RDD上运行时，func的函数类型必须是Iterator[T] => Iterator[U]。假设有N个元素，有M个分区，那么map的函数的将被调用N次,而mapPartitions被调用M次,一个函数一次处理所有分区。
需求：创建一个RDD，使每个元素*2组成新的RDD

 def main(args: Array[String]): Unit = {
    //上下文
    var conf=new SparkConf().setAppName("WordCount").setMaster("local");
    var sc=new SparkContext(conf);
    sc.setLogLevel("ERROR")

    //创建
    var arr=sc.makeRDD(1 to 10);
   //
    var map=arr.mapPartitions(x=>x.map(_*2));

    map.collect().foreach(println);
  }

3 mapPartitionsWithIndex(func)

作用：类似于mapPartitions，但func带有一个整数参数表示分片的索引值，因此在类型为T的RDD上运行时，func的函数类型必须是(Int, Interator[T]) => Iterator[U]；
需求：创建一个RDD，使每个元素跟所在分区形成一个元组组成一个新的RDD


  def main(args: Array[String]): Unit = {
    //上下文
    var conf=new SparkConf().setAppName("WordCount").setMaster("local");
    var sc=new SparkContext(conf);
    sc.setLogLevel("ERROR")

    //创建
    var arr=sc.makeRDD(1 to 5);
   //
    var map=arr.mapPartitionsWithIndex((index,item)=>(item.map((index,_))));
    map.collect().foreach(println);
  }

**4. flatMap(func) **

作用：类似于map，但是每一个输入元素可以被映射为0或多个输出元素

（所以func应该返回一个序列，而不是单一元素）

需求,创建一个二维数组,合并成一维数组


  def main(args: Array[String]): Unit = {
    //上下文
    var conf=new SparkConf().setAppName("WordCount").setMaster("local");
    var sc=new SparkContext(conf);
    sc.setLogLevel("ERROR")

    //创建
   var arr=sc.makeRDD(Array(List(1 , 3),List(2 , 4)));

    var map=arr.flatMap(x=>x);

    map.collect().foreach(println);
  }

5 glom案例

作用：将每一个分区形成一个数组，形成新的RDD类型时RDD[Array[T]]
需求：创建一个4个分区的RDD，并将每个分区的数据放到一个数组

 def main(args: Array[String]): Unit = {
    //上下文
    var conf=new SparkConf().setAppName("WordCount").setMaster("local");
    var sc=new SparkContext(conf);
    sc.setLogLevel("ERROR")

    //创建4个分区
    var arr=sc.makeRDD(1 to 16,4);

    var map=arr.glom();

    map.collect().foreach(arr=>{
       println(arr.mkString(","));
    });
  }

6 groupBy(func)&&filter

字面意思

    //groupby
    var arr=sc.makeRDD(1 to 10);

    var map=arr.groupBy(_%2);

    map.collect().foreach(println);

    //filter
    var arr1=sc.makeRDD(Array("xiaoming","xiaohong","xiaohuang"));
    var map1=arr1.filter(x=>(x.contains("ming")));
    map1.collect().foreach(println);

7. sample(withReplacement, fraction, seed)

作用：随机抽样
参数说明
- withReplacement 抽样后是否放回
- fraction 打分标准,大于fraction就抽出,小于就不抽出
- seed 用于指定随机数生成器种子。
需求：创建一个RDD（1-10），从中选择放回和不放回抽样

    var arr=sc.makeRDD(1 to 10);

    var map=arr.sample(false,0.4,1);

    map.collect().foreach(println);

8. distinct([numTasks])) 案例

作用：对源RDD进行去重后返回一个新的RDD。默认情况下，只有8个并行任务来操作，但是可以传入一个可选的numTasks参数改变它。
需求：创建一个RDD，使用distinct()对其去重。

    var arr=sc.makeRDD(Array(1,2,2,3,4,4,5,6,6));

    var map=arr.distinct();

    map.collect().mkString(",");

9. coalesce(numPartitions) &&repartision

作用：缩减/重分配分区数，用于大数据集过滤后，提高小数据集的执行效率。
需求：创建一个4个分区的RDD，对其缩减/增分区


    var arr=sc.makeRDD(1 to 16,4);
    var map=arr.coalesce(3);
    var m=map.repartition(4);
    println(map.partitions.size);
    println(m.partitions.size);

10.sortBy

    var arr=sc.makeRDD(1 to 16);
    //按照自身大小从小到大
    var map=arr.sortBy(x=>x).collect();
    //降序
    var map1=arr.sortBy(x=>(x,false)).collect();

     //取余3后降序
    var map2=arr.sortBy(x=>(x%3,false)).collect();

4转化操作–双value类型

1. 集合

union(otherDataset)–计算并集
subtract (otherDataset) --计算差集
intersection(otherDataset)–计算交集

    var arr1=sc.makeRDD(1 to 3);
    var arr2=sc.makeRDD(2 to 4);
    var map=arr1.union(arr2);
    map.collect().foreach(println);
    println("-----")
    var map1=arr1.intersection(arr2);
    map1.collect().foreach(println);

2 cartesian(otherDataset)

作用：笛卡尔积,即两个集合元素间一一成对


    var arr1=sc.makeRDD(1 to 3);
    var arr2=sc.makeRDD(2 to 4);
    var map=arr1.cartesian(arr2);
    map.collect().foreach(println);

结果:

(1,2)
(1,3)
(1,4)
(2,2)
(2,3)
(2,4)
(3,2)
(3,3)
(3,4)

3 . zip(otherDataset)案例

作用：将两个RDD组合成Key/Value形式的RDD,这里默认两个RDD的partition数量以及元素数量都相同，否则会抛出异常。
需求：创建两个RDD，并将两个RDD组合到一起形成一个(k,v)RDD

    var arr1=sc.makeRDD(Array("a","b","c"));
    var arr2=sc.makeRDD(Array(1,2,3));
    var map=arr1.zip(arr2);
    map.collect().foreach(println);


结果:
(a,1)
(b,2)
(c,3)

5 RDD转化操作–key-value类型

1 partitionBy 案例

作用：对pairRDD进行分区操作，如果原有的partionRDD和现有的partionRDD是一致的话就不进行分区，否则会生成ShuffleRDD，即会产生shuffle过程。
分区依据:根据传入的分区值,获取原有的hashcode,进行取模运算:
需求：创建一个4个分区的RDD，对其重新分区

    var arr1=sc.makeRDD(Array((1,"a"),(2,"b"),(3,"c"),(4,"d")),4);

    var map=arr1.partitionBy(new org.apache.spark.HashPartitioner(2));

    map.collect().foreach(println);

---------------------
结果:
(2,b)
(4,d)
(1,a)
(3,c)

2 groupByKey案例

作用：根据相同的值进行分组
需求：创建一个pairRDD，将相同key对应值聚合到一个sequence中，并计算相同key对应值的相加结果。

 //1.获取k-v型rdd
    var words = Array("one", "two", "two", "three", "three", "three");
    var rdd=sc.makeRDD(words).map(x=>(x,1));

    //2.根据k进行分组

    var group=rdd.groupByKey();

    //3.将分组的值进行求和

    var result=group.map(x=>(x._1,x._2.sum));

    result.collect().foreach(println);


----result
(two,2)
(one,1)
(three,3)

3 reduceByKey(func, [numTasks]) 案例

在一个(K,V)的RDD上调用，返回一个(K,V)的RDD，使用指定的reduce函数，将相同key的值聚合到一起，reduce任务的个数可以通过第二个可选的参数来设置。
需求：创建一个pairRDD，计算相同key对应值的相加结果

    //1.获取k-v型rdd
   var rdd=sc.parallelize(List(("female",1),("male",5),("female",5),("male",2)));

    var result=rdd.reduceByKey((x,y)=>(x+y));

    result.collect().foreach(println);


------
(male,7)
(female,6)

现在反过头来看经典的统计单词案列,你是否看懂了?

```java
  def main(args: Array[String]): Unit = {
    //上下文
    var conf=new SparkConf().setAppName("WordCount").setMaster("local");
    var sc=new SparkContext(conf);
    sc.setLogLevel("ERROR")

    //1.读取文件,将文件内容一行一行读取
    var lines:RDD[String] =  sc.textFile("in/word.txt");
    //2将一行一行数据分解成一个个单词
     var words:RDD[String]=lines.flatMap(_.split(" "));
    //3.将单词数据进行结构转化,便于统计
    var wordToOne=words.map((_,1));
    //4.两两聚合
   var sum=wordToOne.reduceByKey(_+_)
    //5打印
    var result=sum.collect();
    result.foreach(println);
  }

4 reduceByKey和groupByKey的区别

reduceByKey：按照key进行聚合，在shuffle之前有combine（预聚合）操作，返回结果是RDD[k,v].
groupByKey：按照key进行分组，直接进行shuffle。
开发指导：reduceByKey比groupByKey，建议使用。但是需要注意是否会影响业务逻辑。

5 aggregateByKey案例

参数：(zeroValue:U,[partitioner: Partitioner]) (seqOp: (U, V) => U,combOp: (U, U) => U)

作用：在kv对的RDD中，，按key将value进行分组合并，合并时，将每个value和初始值作为seq函数的参数，进行计算，返回的结果作为一个新的kv对，然后再将结果按照key进行合并，最后将每个分组的value传递给combine函数进行计算（先将前两个value进行计算，将返回结果和下一个value传给combine函数，以此类推），将key与计算结果作为一个新的kv对输出。
参数描述：
（1）zeroValue：给每一个分区中的每一个key一个初始值；
（2）seqOp：函数用于在每一个分区中用初始值逐步迭代value；
（3）combOp：函数用于合并每个分区中的结果。
需求：创建一个pairRDD，取出每个分区相同key对应值的最大值，然后相加
需求分析


    //1.获取k-v型rdd
    val rdd = sc.parallelize(List(("a",3),("a",2),("c",4),("b",3),("c",6),("c",8)),2)
    //取出每个分区相同key对应值的最大值，然后相加
    val result=rdd.aggregateByKey(0)(math.max(_,_),_+_);

    result.collect().foreach(println);

------
(b,3)
(a,3)
(c,12)

6. foldByKey案例
参数：(zeroValue: V)(func: (V, V) => V): RDD[(K, V)]
1.作用：和reduceByKey类似

7 sortByKey([ascending], [numTasks])

作用：在一个(K,V)的RDD上调用，返回一个按照key进行排序的(K,V)的RDD
ascending为bool,决定升降序

8 mapValues案例

针对于(K,V)形式的类型只对V进行操作
需求：创建一个pairRDD，并将value添加字符串"|||"


    val rdd3 = sc.parallelize(Array((1,"a"),(1,"d"),(2,"b"),(3,"c")));
    rdd3.mapValues((value)=>(value+"|||||")).collect().foreach(println);

9 join(otherDataset, [numTasks]) 案例

作用：在类型为(K,V)和(K,W)的RDD上调用，返回一个相同key对应的所有元素对在一起的(K,(V,W))的RDD
需求：创建两个pairRDD，并将key相同的数据聚合到一个元组。

    val rdd = sc.parallelize(Array((1,"a"),(2,"b"),(3,"c")));

    val rdd1=sc.parallelize(Array((1,4),(2,5),(3,6)));

    rdd.join(rdd1).collect().foreach(println);

----------------------
(1,(a,4))
(3,(c,6))
(2,(b,5))

10 cogroup(otherDataset, [numTasks]) 案例

作用：在类型为(K,V)和(K,W)的RDD上调用，返回一个(K,(Iterable,Iterable))类型的RDD
需求：创建两个pairRDD，并将key相同的数据聚合到一个迭代器。

    val rdd = sc.parallelize(Array((1,"a"),(2,"b"),(3,"c")));

    val rdd1=sc.parallelize(Array((1,4),(2,5),(3,6)));

    rdd.cogroup(rdd1).collect().foreach(println);


-------
(1,(CompactBuffer(a),CompactBuffer(4)))
(3,(CompactBuffer(c),CompactBuffer(6)))
(2,(CompactBuffer(b),CompactBuffer(5)))

6. RDD转化操作综合案列–统计广告点击数量

数据结构：省份，城市，广告，中间字段使用空格分割。

样本如下：

asdf aaa 4
asdf aaa 3
asdf aaa 4
asdf aaa 2
asdf aaa 1
qwer asdf 1
qwer asdf 2
qwer asdf 3
qwer asdf 1
qwer asdf 2

需求：统计出每一个省份广告被点击次数的TOP3
思路:

读取文件
按照最小粒度聚合：((Province,AD),1)
计算每个省中每个广告被点击的总数：((Province,AD),sum)
将省份作为key，广告加点击数为value：(Province,(AD,sum))
将同一个省份的所有广告进行聚合(Province,List((AD1,sum1),(AD2,sum2)…))
对同一个省份所有广告的集合进行排序并取前3条，排序规则为广告点击总数

 def main(args: Array[String]): Unit = {
    //上下文
    var conf=new SparkConf().setAppName("WordCount").setMaster("local");
    var sc=new SparkContext(conf);
    sc.setLogLevel("ERROR")

    //读文件
    val rdd=sc.textFile("in/word.txt");

    //转化成((province,AD),1)

    val r1=rdd.map(x=>{
      val line=x.split(" ");
      ((line(0),line(2)),1);
    })

    //计算每个省每个广告被点击总数

    var r2=r1.reduceByKey(_+_);

    //转化成 (province,(AD,times))

    val r3=r2.map(x=>(x._1._1,(x._1._2,x._2)));

    //分组
    var r4=r3.groupByKey();

    //计算前三名的广告

    val r5=r4.mapValues(xml=>{
      xml.toList.sortWith((x,y)=>{
         x._2>y._2
      }).take(3);
    })

    //打印
    r5.collect().foreach(println);

   
  }

加油!!快结束了

7. RDD行为操作

1 基本

collect()–在驱动程序中，以数组的形式返回数据集的所有元素。
count()–返回RDD中元素的个数
first ()–返回第一个元素
take(n)–返回前n个元素
takeOrdered(n)—返回该RDD排序后的前n个元素组成的数组
countByKey()----针对(K,V)类型的RDD，返回一个(K,Int)的map，表示每一个key对应的元素个数。

1 reduce(func)案例

作用：通过func函数聚集RDD中的所有元素，先聚合分区内数据，再聚合分区间数据。
需求：创建一个RDD，将所有元素聚合得到结果。


    val rdd2 = sc.makeRDD(Array(("a",1),("a",3),("c",3),("d",5)));
    val map=rdd2.reduce((x,y)=>{
      (x._1+y._1,x._2+y._2);
    });
    println(map);

-------
(aacd,12)

3 . aggregate案例

参数：(zeroValue: U)(seqOp: (U, T) ⇒ U, combOp: (U, U) ⇒ U)
作用：aggregate函数将每个分区里面的元素通过seqOp和初始值进行聚合，然后用combine函数将每个分区的结果和初始值(zeroValue)进行combine操作。这个函数最终返回的类型不需要和RDD中元素类型一致。
需求：创建一个RDD，将所有元素相加得到结果

   val rdd=sc.makeRDD(1 to 10,2);

    var r=rdd.aggregate(0)(_+_,_+_);
    
    println(r);

----
55

fold(num)(func)–折叠操作，aggregate的简化操作，seqop和combop一样。
countByKey()案例

文件操作

saveAsTextFile(path)
作用：将数据集的元素以textfile的形式保存到HDFS文件系统或者其他支持的文件系统，对于每个元素，Spark将会调用toString方法，将它装换为文件中的文本
saveAsSequenceFile(path)
作用：将数据集中的元素以Hadoop sequencefile的格式保存到指定的目录下，可以使HDFS或者其他Hadoop支持的文件系统。
saveAsObjectFile(path)
作用：用于将RDD中的元素序列化成对象，存储到文件中。