大数据最全spark学习-rdd算子_rdd 18

def mapPartitionsWithIndex[U: ClassTag](
f: (Int, Iterator[T]) => Iterator[U],
preservesPartitioning: Boolean = false): RDD[U]

把数据以分区为单位进行处理，同时也能够获取分区索引，分区索引通常是从0开始

//    1.从集合中获取数据
val rdd: RDD[Int] = sparkContext.makeRDD(List(1, 2, 3, 4), 2)
//    使用mapPartitionsWithIndex,获取第二个分区的数据
val mpiRdd: RDD[Int] = rdd.mapPartitionsWithIndex(
  (index, datas) => {
    if (index == 1)
      {
        datas
      }
     else{
      Nil.toIterator
    }
  }
)

#### 4.flatMap:扁平化处理数据，我认为就是把rdd中可以迭代的数据类型中的数据或者可以再次切分的字符串切割后都放到同一个可迭代对象中。

//    1.从集合中获取数据
val rdd = sparkContext.makeRDD(List(List(1,2),List(3,4)))

//rdd内的数据类型要相同，否则的话会报错
val flatrdd: RDD[Int] = rdd.flatMap(
line => {
line
}
)

如果list内包含不同数据类型**，还需要使用模式匹配，变成相同的数据类型后再处理**

//    1.从集合中有List类型，又有整数类型
val rdd = sparkContext.makeRDD(List(List(1,2),3,List(3,4)))

// flatmap对数据进行扁平化操作
val flatrdd: RDD[Any] = rdd.flatMap(
data => {
data match {
case list: List[_] => list
case dat => List(dat)
}
}
)

#### 5.glom:把同一个分区的数据放到同一个数组内

//    1.从集合中获取数据
val rdd: RDD[Any] = sparkContext.makeRDD(List((1,2), "2", 3, 4), 2)
//    使用glom把个体合并成整体，同一个分区的数据放到同一个数组内

val glomrdd: RDD[Array[Any]] = rdd.glom()
// 输出 如果直接println输出的是数组内的数组，而不是其中的数据
glomrdd.collect().foreach(s=>{
s.foreach(println)
})
println(“0号分区数据=”)
println(glomrdd.collect()(0).mkString(“,”))
println(“1号分区数据=”)
println(glomrdd.collect()(1).mkString(“,”))

#### 6.groupBy:把数据根据指定的规则进行分组


可以根据单词的首字母进行分组，**返回数据的类型是：元组，元组内是分组依据和可迭代对象：（key,可迭代对象）**

//    1.从集合中获取数据
val rdd = sparkContext.makeRDD(List("hello","world","spark","honest"))

//2.使用groupby把首字母相同的放入同一个分组中
val groupbyrdd: RDD[(Char, Iterable[String])] = rdd.groupBy(
num => {
num.charAt(0)
}
)

#### 7.filter()根据指定规则过滤出数据


过滤出list内的奇数

//    1.从集合中获取数据
val rdd: RDD[Int] = sparkContext.makeRDD(List(1, 2, 3, 4))
val filterrdd: RDD[Int] = rdd.filter(
  nums => nums % 2 != 0
)

#### 8.sample:根据指定的规则从数据集中抽取数据


第一个参数boolean表示是否抽取元素是否放回，如果放回表示一个元素可能重复出现


第二个参数表示每个元素被抽取到的概率，范围是[ 0,1]


第三个参数表示随机种子数，输入一个正整数


实现原理：根据种子和随机算法算出一个数和第二个参数设置几率比较，小于第二个参数要，大于第二个参数则不要

//    1.从集合中获取数据
val rdd: RDD[Int] = sparkContext.makeRDD(List(1, 2, 3, 4))
val samplerdd: RDD[Int] = rdd.sample(
  false, 0.5
)

#### 9.distinct:去除数据集中重复的元素,可以指定新生成的RDD的分区数

val distinctRDD = originalRDD.distinct([numPartitions])

numPartitions用于指定分区数


#### 10.coalesce:用于合并分区减少分区的数量

val conf = new SparkConf().setAppName(“CoalesceExample”).setMaster(“local”)
val sc = new SparkContext(conf)

val data = sc.parallelize(1 to 10, 5) // 创建5个分区的RDD
val coalescedData = data.coalesce(2) // 合并成两个分区

#### 11.repartition:可以增加或者减少分区数量

def repartition(numPartitions: Int)(implicit ord: Ordering[T] = null): RDD[T]

#### 12.sortBy用于排序数据

val sortedRDD = originalRDD.sortBy(func, ascending = true, numPartitions)

// func用于指定排序的依据
//ascending如果指定为true的话就是升序，false是降序
//numPartitions用来指定排序后的RDD数量，不写的话默认是原有RDD的分区数

### 双value类型


#### 13.intersection：求两个RDD的数据交集

val dataRDD1 = sparkContext.makeRDD(List(1,2,3,4))
val dataRDD2 = sparkContext.makeRDD(List(3,4,5,6))
val dataRDD = dataRDD1.intersection(dataRDD2)

#### 14.union：求两个RDD数据的并集

val dataRDD1 = sparkContext.makeRDD(List(1,2,3,4))
val dataRDD2 = sparkContext.makeRDD(List(3,4,5,6))
val dataRDD = dataRDD1.union(dataRDD2)

#### 15.subtract：去除两个RDD的数据的重复部分，保留其他数据

val dataRDD1 = sparkContext.makeRDD(List(1,2,3,4))
val dataRDD2 = sparkContext.makeRDD(List(3,4,5,6))
val dataRDD = dataRDD1.subtract(dataRDD2)

#### 16.zip


将两个 RDD 中的元素，以键值对的形式进行合并。其中，键值对中的 Key 为第 1 个 RDD 中的元素，Value 为第 2 个 RDD 中的相同位置的元素。

val dataRDD1 = sparkContext.makeRDD(List(1,2,3,4))
val dataRDD2 = sparkContext.makeRDD(List(3,4,5,6))
val dataRDD = dataRDD1.zip(dataRDD2)

### key-value类型


#### **17.partitionBy**


将数据按照指定 Partitioner 重新进行分区。Spark 默认的分区器是 HashPartitioner(分区数量)

val rdd = sparkContext.makeRDD(List((1,1),(2,1),(3,1),(4,1)),2)

rdd.partitionBy(new HashPartitioner(2))

HashPartitioner是根据key的哈希码与分区数进行取余，根据取余的结果来对数据进行分区。


**返回数据类型是一个元组.**


#### 18.reduceByKey:按照相同的key对value进行聚合

def reduceByKey(func: (V, V) => V, numPartitions: Int): RDD[(K, V)]

可以指定聚合后的分区数量，默认是原RDD的分区数，返回值类型是元组


#### 19.groupByKey:将数据源的数据根据 key 对 value 进行分组

val dataRDD1 =
sparkContext.makeRDD(List((“a”,1),(“b”,2),(“c”,3)))
val dataRDD2 = dataRDD1.groupByKey()
//指定分区数量是2
val dataRDD3 = dataRDD1.groupByKey(2)
//指定分区规则
val dataRDD4 = dataRDD1.groupByKey(new HashPartitioner(2))

#### 20.aggregateByKey:将数据根据不同的规则进行分区内计算和分区间计算

val dataRDD1 =
sparkContext.makeRDD(List((“a”,1),(“b”,2),(“c”,3)))
val dataRDD2 =
dataRDD1.aggregateByKey(0)(+,*)

第一个括号内表示的是初始值（**初始值决定了返回的数据类型**），第二个括号内第一个参数表示分区内进行的操作，第二个参数表示分区间进行的操作，分区内和分区间的操作可以相同也可以不同。


#### 21.foldByKey:当aggregateByKey分区内和分区间操作相同时就是foldByKey

val dataRDD1 = sparkContext.makeRDD(List((“a”,1),(“b”,2),(“c”,3)))
val dataRDD2 = dataRDD1.foldByKey(0)(+)

#### 22.combineByKey:有3个参数，第一个参数表示value的格式，第二个参数表示相同key的value在分区内进行的操作，第三个参数表示相同key的value在分区间进行的操作

//    1.从集合中获取数据，求每个k对应数据的平均值
val rdd: RDD[(String, Int)] = sparkContext.makeRDD(List(("a", 1), ("a"  , 2), ("b", 3), ("b", 4), ("b", 5), ("a", 6)))
val combinrdd: RDD[(String, (Int, Int))] = rdd.combineByKey(

// v代表原始RDD内的value,1代表出现的次数
v => (v, 1),
// 分区内进行 操作
(t: (Int, Int), v) => {
// (相同key的value值相加，记录出现次数)
(t._1 + v, t._2 + 1)
}
,
(t1: (Int, Int), t2: (Int, Int)) => {
(t1._1 + t2._1, t1._2 + t2._2)
}
)

#### 23.sortByKey:按照key对数据进行升序或者降序

def sortByKey(ascending: Boolean = true, numPartitions: Int = self.partitions.length)

RDD[(K, V)]

val dataRDD1 = sparkContext.makeRDD(List((“a”,1),(“b”,2),(“c”,3)))
val sortRDD1: RDD[(String, Int)] = dataRDD1.sortByKey(true)
val sortRDD1: RDD[(String, Int)] = dataRDD1.sortByKey(false)

#### 24.join


在类型为(K,V)和(K,W)的 RDD 上调用，返回一个相同 key 对应的所有元素连接在一起的 (K,(V,W))的 RDD

val rdd: RDD[(Int, String)] = sc.makeRDD(Array((1, “a”), (2, “b”), (3, “c”)))
val rdd1: RDD[(Int, Int)] = sc.makeRDD(Array((1, 4), (2, 5), (3, 6)))
rdd.join(rdd1).collect().foreach(println)

#### 25.leftOuterJoin:左外连接

val dataRDD1 = sparkContext.makeRDD(List((“a”,1),(“b”,2),(“c”,3)))
val dataRDD2 = sparkContext.makeRDD(List((“a”,1),(“b”,2),(“c”,3)))
val rdd: RDD[(String, (Int, Option[Int]))] = dataRDD1.leftOuterJoin(dataRDD2)

#### 26.cogroup


在类型为(K,V)和(K,W)的 RDD 上调用，返回一个(K,(Iterable,Iterable))类型的 RDD

val dataRDD1 = sparkContext.makeRDD(List((“a”,1),(“a”,2),(“c”,3)))
val dataRDD2 = sparkContext.makeRDD(List((“a”,1),(“c”,2),(“c”,3)))
val value: RDD[(String, (Iterable[Int], Iterable[Int]))] =
dataRDD1.cogroup(dataRDD2)

### 行动算子


#### 1.reduce：先聚合分区内，再聚合分区间

val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4)) // 聚合数据
val reduceResult: Int = rdd.reduce(+)

#### 2.collect:以数组形式返回RDD内的数据

val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4))
// 收集数据到 Driver
rdd.collect().foreach(println)

#### 3.count：返回RDD内的元素个数


![img](https://img-blog.csdnimg.cn/img_convert/765fb66e40c4235bee7b167f23e72eb0.png)
![img](https://img-blog.csdnimg.cn/img_convert/22f65482ad2cecd5df154611b5f60689.png)
![img](https://img-blog.csdnimg.cn/img_convert/1fb631d333538b22ee930f939b5d7cbe.png)

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618545628)**

river
rdd.collect().foreach(println)

3.count：返回RDD内的元素个数

[外链图片转存中…(img-b36982eM-1714769757798)]
[外链图片转存中…(img-5YuhPcxm-1714769757799)]
[外链图片转存中…(img-LSo5Qw08-1714769757799)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

需要这份系统化资料的朋友，可以戳这里获取