目录
•第一种是将程序中已存在的Seq集合（如集合、列表、数组）转换成RDD。
•第二种是对已有RDD进行转换得到新的RDD，这两种方法都是通过内存中已有的集合创建RDD的。
•第二种方式是通过接收一个是Seq[(T,Seq[String])]参数类型创建RDD。
Ø从外部存储系统中读取数据创建RDD是指直接读取存放在文件系统中的数据文件创建RDD。
Ø从内存中读取数据创建RDD的方法常用于测试，从外部存储系统中读取数据创建RDD才是用于实践操作的常用方法。
Ø分别读取HDFS文件和Linux本地文件的数据并创建RDD，具体操作如下。
•collect：直接调用collect返回该RDD中的所有元素，返回类型是一个Array[T]数组。
4.3： 使用combineByKey()方法合并相同键的值
一：RDD
A：RDD的概念：
RDD是一个容错的、只读的、可进行并行操作的数据结构，是一个分布在集群各个节点中的存放元素的集合。
B：RDD3种不同的创建方法：
•第一种是将程序中已存在的Seq集合（如集合、列表、数组）转换成RDD。
val data = Seq(1, 2, 3, 4, 5)
val rdd = sc.parallelize(data)•第二种是对已有RDD进行转换得到新的RDD，这两种方法都是通过内存中已有的集合创建RDD的。
val squaredRDD = rdd.map(x => x * x)•第三种是直接读取外部存储系统的数据创建RDD。
val textFileRDD = sc.textFile("hdfs://myHDFS/data.txt")C: 从内存中读取数据创建RDD
1. parallelize()
Øparallelize()方法有两个输入参数，说明如下。
•要转化的集合，必须是Seq集合。Seq表示序列，指的是一类具有一定长度的、可迭代访问的对象，其中每个数据元素均带有一个从0开始的、固定的索引。
分区数。若不设分区数，则RDD的分区数默认为该程序分配到的资源的CPU核心数。
从现有集合创建RDD
在Scala中，可以通过parallelize方法直接将本地集合转换成RDD。这个方法接受一个集合和一个可选的分区数参数，如果不提供分区数，则会使用系统的默认分区数。例如：
val myRDD = sc.parallelize(Seq(1, 2, 3, 4, 5))如果需要指定分区数，可以提供第二个参数：
val myRDD = sc.parallelize(Seq(1, 2, 3, 4, 5), 3)从外部存储创建RDD
除了本地集合，还可以直接从外部存储系统（如HDFS）创建RDD。这通常通过textFile、binaryFile等方法实现，后面我们会详细介绍这些方法。
2． makeRDD()
ØmakeRDD()方法有两种使用方式。
•第一种方式的使用与parallelize()方法一致；
•第二种方式是通过接收一个是Seq[(T,Seq[String])]参数类型创建RDD。
Ø第二种方式生成的RDD中保存的是T的值，Seq[String]部分的数据会按照Seq[(T,Seq[String])]的顺序存放到各个分区中，一个Seq[String]对应存放至一个分区，并为数据提供位置信息，通过preferredLocations()方法可以根据位置信息查看每一个分区的值。调用makeRDD()时不可以直接指定RDD的分区个数，分区的个数与Seq[String]参数的个数是保持一致的。
def makeRDD[T: ClassTag](
seq: Seq[T],
numSlices: Int = defaultParallelism): RDD[T]D:从外部存储系统中读取数据创建RDD
Ø从外部存储系统中读取数据创建RDD是指直接读取存放在文件系统中的数据文件创建RDD。
Ø从内存中读取数据创建RDD的方法常用于测试，从外部存储系统中读取数据创建RDD才是用于实践操作的常用方法。
Ø从外部存储系统中读取数据创建RDD可以有很多种数据来源，可通过SparkContext对象的textFile()方法读取数据集，该方法支持多种类型的数据集，如目录、文本文件、压缩文件和通配符匹配的文件等，并且允许设定分区个数。
def textFile(path: String): RDD[String]使用binaryFile方法
对于二进制文件，可以使用binaryFile方法。
def binaryFile(path: String, codec: Codec): RDD[BinaryFile]Ø分别读取HDFS文件和Linux本地文件的数据并创建RDD，具体操作如下。
•通过HDFS文件创建RDD
直接通过textFile()方法读取HDFS文件的位置即可。
•通过Linux本地文件创建RDD
本地文件的读取也是通过sc.textFile("路径")的方法实现的，在路径前面加上“file://”表示从Linux本地文件系统读取。在IntelliJ IDEA开发环境中可以直接读取本地文件；但在spark-shell中，要求在所有节点的相同位置保存该文件才可以读取它.
二：RDD使用方法
1.使用map()方法转换数据
Ømap()方法是一种基础的RDD转换操作，可以对RDD中的每一个数据元素通过某种函数进行转换并返回新的RDD。
Ømap()方法是转换操作，不会立即进行计算。
Ø转换操作是创建RDD的第二种方法，通过转换已有RDD生成新的RDD。因为RDD是一个不可变的集合，所以如果对RDD数据进行了某种转换，那么会生成一个新的RDD。
2.使用sortBy()方法进行排序
ØsortBy()方法用于对标准RDD进行排序，有3个可输入参数，说明如下。
•第1个参数是一个函数f:(T) => K，左边是要被排序对象中的每一个元素，右边返回的值是元素中要进行排序的值。
•第2个参数是ascending，决定排序后RDD中的元素是升序的还是降序的，默认是true，即升序排序，如果需要降序排序那么需要将参数的值设置为false。
•第3个参数是numPartitions，决定排序后的RDD的分区个数，默认排序后的分区个数和排序之前的分区个数相等，即this.partitions.size。
Ø第一个参数是必须输入的，而后面的两个参数可以不输入。
3.使用collect()方法查询数据
Øcollect()方法是一种行动操作，可以将RDD中所有元素转换成数组并返回到Driver端，适用于返回处理后的少量数据。
Ø因为需要从集群各个节点收集数据到本地，经过网络传输，并且加载到Driver内存中，所以如果数据量比较大，会给网络传输造成很大的压力。
Ø因此，数据量较大时，尽量不使用collect()方法，否则可能导致Driver端出现内存溢出问题。
Øcollect()方法有以下两种操作方式。
•collect：直接调用collect返回该RDD中的所有元素，返回类型是一个Array[T]数组。
•collect[U: ClassTag](f: PartialFunction[T, U])：RDD[U]。这种方式需要提供一个标准的偏函数，将元素保存至一个RDD中。首先定义一个函数one，用于将collect方法得到的数组中数值为1的值替换为“one”，将其他值替换为“other”。
4.使用flatMap()方法转换数据
ØflatMap()方法将函数参数应用于RDD之中的每一个元素，将返回的迭代器（如数组、列表等）中的所有元素构成新的RDD。
Ø使用flatMap()方法时先进行map（映射）再进行flat（扁平化）操作，数据会先经过跟map一样的操作，为每一条输入返回一个迭代器（可迭代的数据类型），然后将所得到的不同级别的迭代器中的元素全部当成同级别的元素，返回一个元素级别全部相同的RDD。
这个转换操作通常用来切分单词
5.使用take()方法查询某几个值
Øtake(N)方法用于获取RDD的前N个元素，返回数据为数组。
Øtake()与collect()方法的原理相似，collect()方法用于获取全部数据，take()方法获取指定个数的数据。
Ø获取RDD的前5个元素
6.使用union()方法合并多个RDD
Øunion()方法是一种转换操作，用于将两个RDD合并成一个，不进行去重操作，而且两个RDD中每个元素中的值的个数、数据类型需要保持一致。
Ø使用union()方法合并两个RDD
7.使用filter()方法进行过滤
Øfilter()方法是一种转换操作，用于过滤RDD中的元素。
Øfilter()方法需要一个参数，这个参数是一个用于过滤的函数，该函数的返回值为Boolean类型。
Øfilter()方法将返回值为true的元素保留，将返回值为false的元素过滤掉，最后返回一个存储符合过滤条件的所有元素的新RDD。
Ø创建一个RDD，并且过滤掉每个元组第二个值小于等于1的元素。
8.使用distinct()方法进行去重
Ødistinct()方法是一种转换操作，用于RDD的数据去重，去除两个完全相同的元素，没有参数。
Ø创建一个带有重复数据的RDD，并使用distinct()方法去重。
9.使用简单的集合操作
ØSpark中的集合操作常用方法（转换操作）
| 方法 | 描述 |
| union() | 参数是RDD，合并两个RDD的所有元素 |
| intersection() | 参数是RDD，求出两个RDD的共同元素 |
| subtract() | 参数是RDD，将原RDD里和参数RDD里相同的元素去掉 |
| cartesian() | 参数是RDD，求两个RDD的笛卡儿积 |
a.intersection()方法
Øintersection()方法用于求出两个RDD的共同元素，即找出两个RDD的交集，参数是另一个RDD，先后顺序与结果无关。
Ø创建两个RDD，其中有相同的元素，通过intersection()方法求出两个RDD的交集。
b.subtract()方法
Øsubtract()方法用于将前一个RDD中在后一个RDD出现的元素删除，可以认为是求补集的操作，返回值为前一个RDD去除与后一个RDD相同元素后的剩余值所组成的新的RDD。两个RDD的顺序会影响结果。
Ø创建两个RDD，分别为rdd1和rdd2，包含相同元素和不同元素，通过subtract()方法求rdd1和rdd2彼此的补集。
c. cartesian()方法
Øcartesian()方法可将两个集合的元素两两组合成一组，即求笛卡儿积。
Ø创建两个RDD，分别有4个元素，通过cartesian()方法求两个RDD的笛卡儿积。
import org.apache.spark.SparkConf
import org.apache.spark.SparkContext
val conf = new SparkConf().setAppName("SimpleRDDExample").setMaster("local[2]")
val sc = new SparkContext(conf)
// 使用parallelize创建RDD
val rdd1 = sc.parallelize(Seq(1, 2, 3, 4, 5), 3)
// 使用makeRDD创建RDD，并提供位置偏好
val rdd2 = sc.makeRDD(Seq((1, List("node1")), (2, List("node2"))), 2)
// 使用textFile从外部文件创建RDD
val rdd3 = sc.textFile("hdfs://myHDFS/data.txt")
// 转换操作：map
val mappedRDD = rdd1.map(x => x * x)
// 转换操作：filter
val filteredRDD = rdd1.filter(x => x % 2 == 0)
// 转换操作：reduce
val reduced = rdd1.reduce(_+_)
// 输出结果
mappedRDD.collect().foreach(println)
filteredRDD.collect().foreach(println)
reduced三：键值对对RDD
3.1：了解
3.2： 创建
3.3：使用键值对RDD的keys和values方法
3.4：使用键值对RDD的reduceByKey()方法
Ø在进行处理时，reduceByKey()方法将相同键的前两个值传给输入函数，产生一个新的返回值，新产生的返回值与RDD中相同键的下一个值组成两个元素，再传给输入函数，直到最后每个键只有一个对应的值为止。reduceByKey()方法不是一种行动操作，而是一种转换操作。
3.5：使用键值对RDD的groupByKey()方法
四：合并连接RDD
4.1：使用join()方法连接两个RDD
| 连接方法 | 描述 |
| join() | 对两个RDD进行内连接 |
| rightOuterJoin() | 对两个RDD进行连接操作，确保第二个RDD的键必须存在（右外连接） |
| leftOuterJoin() | 对两个RDD进行连接操作，确保第一个RDD的键必须存在（左外连接） |
| fullOuterJoin() | 对两个RDD进行全外连接 |
（1）join()方法
（2）rightOuterJoin()方法
3）leftOuterJoin()方法
ØleftOuterJoin()方法用于根据键对两个RDD进行左外连接，与rightOuterJoin()方法相反，返回结果保留左边RDD的所有键。
（4）fullOuterJoin()方法
4.2： 使用zip()方法组合两个RDD
4.3： 使用combineByKey()方法合并相同键的值
combineByKey(createCombiner,mergeValue,mergeCombiners,numPartitions=None)
4.4： 使用lookup()方法查找指定键的值
Ølookup(key:K)方法作用于键值对RDD，返回指定键的所有值。
综合方法代码例子
import org.apache.spark.SparkConf
import org.apache.spark.SparkContext
val conf = new SparkConf().setAppName("SimpleRDDExample").setMaster("local[2]")
val sc = new SparkContext(conf)
// 使用parallelize创建RDD
val rdd1 = sc.parallelize(Seq(1, 2, 3, 4, 5), 3)
// 使用makeRDD创建RDD，并提供位置偏好
val rdd2 = sc.makeRDD(Seq((1, List("node1")), (2, List("node2"))), 2)
// 使用textFile从外部文件创建RDD
val rdd3 = sc.textFile("hdfs://myHDFS/data.txt")
// 转换操作：map
val mappedRDD = rdd1.map(x => x * x)
// 转换操作：filter
val filteredRDD = rdd1.filter(x => x % 2 == 0)
// 转换操作：reduce
val reduced = rdd1.reduce(_+_)
// 输出结果
mappedRDD.collect().foreach(println)
filteredRDD.collect().foreach(println)
reduced五：读取与存储json文件
5.1：Spark支持的一些常见文件格式
| 格式名称 | 结构化 | 描述 |
| JSON | 半结构化 | 常见的基于文本的格式，半结构化；大多数库要求每行一条记录 |
| CSV | 是 | 非常常见的基于文本的格式，通常在电子表格应用中使用 |
| SequenceFile | 是 | 一种用于键值对数据的常见Hadoop文件格式 |
| 文本文件 | 否 | 普通的文本文件，每一行一条记录 |
| 对象文件 | 是 | 用来存储Spark作业中的数据，改变类时会失效，因为对象文件依赖于Java序列化 |
（1）JSON文件的读取
（2）JSON文件的存储
5.2：读取与存储CSV文件
（1）CSV文件的读取
（2）CSV文件的存储
5.3：读取与存储SequenceFile文件
（1）SequenceFile文件的存储
（2）SequenceFile文件的读取
5.3：读取与存储文本文件
1）文本文件的读取
通过textFile()方法即可直接读取，一条记录（一行）作为一个元素。
（2）文本文件的存储
六：搭建spark开发环境
idea下安装scala插件
七：配置spark运行环境
1.添加spark开发依赖包
- 添加本地依赖：当您需要使用本地已有的库或组件时，需要将其添加到IDEA中。这通常涉及到配置项目的
pom.xml文件或使用IDEA的图形界面进行设置。
2.编写程序
- 编写程序：在IDEA中创建新的Java类或文件，并编写所需的代码。
3.运行程序
使用IDEA的运行功能，编译并执行您的程序，观察输出结果。
下面我们将详细讨论如何在IDEA中添加本地依赖，并运行Java程序。
添加本地依赖
使用Maven管理依赖
如果您使用的是Maven项目，可以通过修改pom.xml文件来添加本地依赖。您需要在该文件中添加一个<dependency>标签，指定本地依赖的groupId、artifactId和version等信息。例如：
<dependency>
<groupId>com.example</groupId>
<artifactId>my-local-lib</artifactId>
<version>1.0</version>
<scope>system</scope>
<systemPath>${basedir}/lib/my-local-lib.jar</systemPath>
</dependency>在这里，<systemPath>指向您的本地依赖库的位置。确保您已经将本地依赖库放置在正确的目录下，并在pom.xml中正确指定了路径8。
手动添加依赖
如果不想使用Maven，可以直接手动添加依赖。在IDEA中，您可以通过右键点击项目名，选择“Open Module Settings”，然后在“Dependencies”标签页中添加本地依赖。这种方法更加直观，但需要您手动管理所有的依赖关系5。
运行Java程序
创建和编译项目
首先，您需要创建一个新的Java项目，然后在项目中创建Java类。在IDEA中，您可以通过菜单File -> New -> Project来创建项目，并通过File -> New -> Java Class来创建类910。
运行程序
一旦编写完代码，就可以运行程序了。在IDEA中，您可以通过点击工具栏上的“Run”按钮来编译和运行您的程序。如果您只想运行某个特定的类或方法，可以使用快捷键Ctrl + Shift + F10来选择运行的目标12。
总结
在IDEA中添加本地依赖并运行Java程序，涉及到对项目依赖关系的配置，以及使用IDEA的编译和运行功能。通过Maven或手动添加依赖，您可以方便地将本地库整合到项目中。而运行程序则需要您在IDEA中进行编译，并执行相应的运行命令。在整个过程中，IDEA提供了便捷的工具和选项，使得本地依赖的添加和程序的运行变得十分简单。
八：如何在Spark中添加第三方依赖
使用Maven管理依赖
最常见的方式是通过Maven来管理依赖。Maven是一个强大的构建工具，它可以自动下载和管理各种依赖库。您只需在项目的pom.xml文件中添加所需的依赖，如下所示：
<dependencies>
<dependency>
<groupId>org.apache.spark</groupId>
<artifactId>spark-core_2.12</artifactId>
<version>3.1.2</version>
</dependency>
<dependency>
<groupId>com.example</groupId>
<artifactId>example-library</artifactId>
<version>1.0.0</version>
</dependency>
</dependencies>在Spark Shell中添加依赖
如果您正在使用Spark Shell进行开发，可以通过--packages参数来添加依赖。例如，要在Spark Shell中使用example-library，您可以这样启动Spark Shell：
spark-shell --packages com.example:example-library:1.0.0在Spark Submit中添加依赖
对于将应用程序提交到Spark集群的情况，您也可以使用--packages参数，例如：
spark-submit --class com.example.MyApp --master yarn --deploy-mode client --packages com.example:example-library:1.0.0 myApp.jar注意事项
- 确保您在所有可能运行Spark任务的机器上都安装了依赖库，或者在提交代码时指定正确的依赖路径。
- 如果依赖库是多个jar文件的集合，您可能需要使用
--jars参数来指定所有依赖库的位置。 - 如果您使用的是Spark 2.0及以上版本，则可以在应用程序的配置中直接指定依赖，无需使用
--packages或--jars参数。
实际案例
假设我们要在Spark中添加一个自定义的依赖，比如my-custom-lib。我们可以按照以下步骤操作：
-
确保
my-custom-lib已经发布到了Maven仓库。 -
在项目的
pom.xml中添加依赖：<dependency> <groupId>com.mycompany</groupId> <artifactId>my-custom-lib</artifactId> <version>1.0.0</version> </dependency> -
如果您使用的是Spark Shell或Spark Submit，那么直接运行相应的命令即可：
spark-shell --packages com.mycompany:my-custom-lib:1.0.0或者
spark-submit --class com.example.MyApp --master yarn --deploy-mode client --packages com.mycompany:my-custom-lib:1.0.0 myApp.jar -
如果依赖不是通过Maven管理的，而是通过其他方式，如源码编译或本地文件，那么您需要在Spark应用程序中指定这些依赖的路径。
结语
通过上述方法，您应该能够成功地将第三方依赖添加到Spark项目中，并利用这些依赖扩展Spark的功能。无论是开发环境还是生产环境，选择合适的方法都可以让您轻松地使用第三方库来处理大数据数据。
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
