Spark-Core核心算子

文章目录

    • 一、数据源获取
      • 1、从集合中获取
      • 2、从外部存储系统创建
      • 3、从其它RDD中创建
      • 4、分区规则—load数据时
    • 二、转换算子(Transformation)
      • 1、Value类型
        • 1.1 map()_
        • 1.2 mapPartitions()
        • 1.3 mapPartitionsWithIndex(不常用)
        • 1.4 filterMap()_扁平化(合并流)
        • 1.5 groupBy()_分组
        • 1.6 filter()_过滤
        • 1.7 distinct()_去重
        • 1.8 coalesce()_合并分区
        • 1.9 repartition()_重新分区
        • 1.10 sortBy()_排序
        • 1.11 map和mapPartitions区别
        • 1.12 coalesce和repartition区别
      • 2、双-Value类型
        • 2.1 intersection()_交集
        • 2.2 union()_并集不去重
        • 2.3 subtract()_差集
        • 2.4 zip()_拉链
      • 3、Key—Value类型
        • 3.1 partitionBy()_按照K重新分区
        • 3.2 groupByKey()_按照K重新分组
        • 3.3 reduceByKey()_按照K聚合V
        • 3.4 aggregateByKey()_不同逻辑的归约
        • 3.5 sortByKey()_按照K进行排序
        • 3.6 mapValues()_只对V进行操作
        • 3.7 join()_等同于sql内连接
        • 3.8 cogroup()_类似于sql全连接
        • 3.9 自定义分区器
        • 3.10 reduceByKey和groupByKey区别
    • 三、行动算子(Action)
      • 1、collect()_以数组的形式返回数据集
      • 2、count()_返回RDD中元素个数
      • 3、first()_返回RDD中的第一个元素
      • 4、take()_返回由RDD前n个元素组成的数组
      • 5、takeOrdered()_返回排序后前n个元素
      • 6、countByKey()_统计每种key的个数
      • 7、saveAsTextFile(path)_保存成Text文件
      • 8、saveAsSequenceFile(path)_保存成Sequencefile文件
      • 9、saveAsObjectFile(path)_序列化成对象保存到文件
      • 10、foreach()_遍历RDD中每一个元素


一、数据源获取

1、从集合中获取

sc.parallelize(list)
sc.makeRDD(list)
sc.makeRDD(list, 2)
val list: List[Int] = List(1, 2, 3, 4, 5)
//  从List中创建RDD
val rdd01: RDD[Int] = sc.parallelize(list)
//  底层调用parallelize。从结合list中获取数据
val rdd02: RDD[Int] = sc.makeRDD(list)
//  2:分区数量为2
val rdd03: RDD[Int] = sc.makeRDD(list, 2)

2、从外部存储系统创建

//	从文件中获取
sc.textFile("input/1.txt")
//  无论文件中存储的是什么数据,读取过来都当字符串进行处理
val rdd04: RDD[String] = sc.textFile("input/1.txt")

3、从其它RDD中创建

在其它执行步骤完成后,生成新的RDD对象

val rdd05: RDD[String] = rdd04.map(_ * 2)

4、分区规则—load数据时

从集合中创建

从文件中创建

二、转换算子(Transformation)

//  1、创建SparkConf并设置App名称
val conf = new SparkConf().setAppName("SparkCore").setMaster("local[*]")
//  2、创建SparkContext,该对象时提交Spark APP 的入口
val sc = new SparkContext(conf)
//  3、创建RDD
val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4))
//  4、具体执行步骤
val rdd01: RDD[Int] = rdd.map(x => x * 20)
//  5、打印结果
println(rdd01.collect().toList)
//  6、关闭连接
sc.stop()

1、Value类型

1.1 map()_

在这里插入图片描述

//  4、具体执行步骤
val rdd01: RDD[Int] = rdd.map(x => x * 20)
//  4、具体执行步骤
val rdd02: RDD[Int] = rdd01.map(_ * 20)

1.2 mapPartitions()

以分区为单位执行的map()

在这里插入图片描述

1.3 mapPartitionsWithIndex(不常用)

  • 里面的函数针对每个分区操作,分区有多少个,函数就执行多少次。
  • 函数的第一个参数代表分区号。
  • 函数的第二个参数代表分区数据迭代器。
  /**** @param f                     分区编号* @param preservesPartitioning 分区数据迭代器*/
def mapPartitionsWithIndex[U: ClassTag](f: (Int, Iterator[T]) => Iterator[U],preservesPartitioning: Boolean = false): RDD[U] = withScope {}
rdd03.mapPartitionsWithIndex((index, items) => {items.map((index, _))
})
//	指定迭代器规则,并使用分区数据迭代器
rdd03.mapPartitionsWithIndex((index, items) => {items.map((index, _))
}, preservesPartitioning = true)

1.4 filterMap()_扁平化(合并流)

扁平化(合并流)

功能说明

  • 与map操作类似,将RDD中的每一个元素通过应用f函数依次转换为新的元素,并封装到RDD中。
  • 区别:在flatMap操作中,f函数的返回值是一个集合,并且会将每一个该集合中的元素拆分出来放到新的RDD中。

在这里插入图片描述

def flatMap[U: ClassTag](f: T => TraversableOnce[U]): RDD[U] = withScope {}
val rdd08: RDD[List[Int]] = sc.makeRDD(List(List(1, 2), List(3, 4), List(5, 6)), 2)
val rdd09: RDD[Int] = rdd08.flatMap(list => list)
//	List(1, 2, 3, 4, 5, 6)
println(rdd09.collect().toList)

1.5 groupBy()_分组

分组

按照传入函数的返回值进行分组。将相同的key对应的值放入一个迭代器。

在这里插入图片描述

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

在这里插入图片描述

def groupBy[K](f: T => K)(implicit kt: ClassTag[K]): RDD[(K, Iterable[T])] = withScope {groupBy[K](f, defaultPartitioner(this))
}

案例

// 3.2 将每个分区的数据放到一个数组并收集到Driver端打印
rdd.groupBy((x)=>{x%2})
// 简化
rdd.groupBy(_%2)
val rdd10: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4, 5, 6, 7, 8, 9), 3)
//  (0,CompactBuffer(2, 4, 6, 8))
//  (1,CompactBuffer(1, 3, 5, 7, 9))
rdd10.groupBy(_ % 2).collect().foreach(println)
val rdd11: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4, 5), 3)
//  按照数字相同进行分区
//  (3,CompactBuffer(3))
//  (4,CompactBuffer(4))
//  (1,CompactBuffer(1))
//  (5,CompactBuffer(5))
//  (2,CompactBuffer(2))
rdd11.groupBy(a => a).collect().foreach(println)

1.6 filter()_过滤

过滤

接收一个返回值为布尔类型的函数作为参数。当某个RDD调用filter方法时,会对该RDD中每一个元素应用f函数,如果返回值类型为true,则该元素会被添加到新的RDD中。

在这里插入图片描述

rdd11.filter(a => a % 2 == 0)
rdd11.filter(_% 2 == 0)
val rdd11: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4, 5, 6, 7, 8, 9), 3)
val rdd110: RDD[Int] = rdd11.filter(a => a % 2 == 0)
//  List(2, 4, 6, 8)
println(rdd110.collect().toList)

1.7 distinct()_去重

去重

  • 对内部的元素去重,并将去重后的元素放到新的RDD中。
  • 默认情况下,distinct会生成与原RDD分区个数一致的分区数。
  • 用分布式的方式去重比HashSet集合方式不容易OOM。

在这里插入图片描述

//	去重
rdd.distinct()
//	去重(2并发度)
rdd.distinct(2)
val rdd12: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4, 2, 3), 3)
//  List(3, 4, 1, 2)
println(rdd12.distinct().collect().toList)
//  List(4, 2, 1, 3)(采用多个Task提高并发读)
println(rdd12.distinct(2).collect().toList)

1.8 coalesce()_合并分区

合并分区

  • Coalesce算子包括:配置执行Shuffle和配置不执行Shuffle两种方式。
  • 缩减分区数,用于大数据集过滤后,提高小数据集的执行效率。

在这里插入图片描述

rdd13.coalesce(2)
rdd14.coalesce(2, shuffle = true)

缩减分区并执行Shuffer

val rdd14: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4, 5, 6, 7, 8, 9), 3)
//  缩减分区为2个
val rdd131: RDD[Int] = rdd13.coalesce(2)
//  缩减分区为2个,并执行Shuffer
val rdd141: RDD[Int] = rdd14.coalesce(2, shuffle = true)

1.9 repartition()_重新分区

重新分区

  • 执行Shuffle。
  • 该操作内部其实执行的是coalesce操作,参数shuffle的默认值为true。
  • 无论是将分区数多的RDD转换为分区数少的RDD,还是将分区数少的RDD转换为分区数多的RDD,repartition操作都可以完成,因为无论如何都会经shuffle过程。
  • 分区规则不是hash,因为平时使用的分区都是按照hash来实现的,repartition一般是对hash的结果不满意,想要打散重新分区。

在这里插入图片描述

rdd.repartition(2)
val rdd15: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4, 5, 6, 7, 8, 9), 3)
//  重新分区
val rdd151: RDD[Int] = rdd15.repartition(2)

1.10 sortBy()_排序

排序

  • 该操作用于排序数据。
  • 在排序之前,可以将数据通过f函数进行处理,之后按照f函数处理的结果进行排序,默认为正序排列。
  • 排序后新产生的RDD的分区数与原RDD的分区数一致。
  • 实现正序和倒序排序。

在这里插入图片描述

//	正序
rdd.sortBy(num => num)
//	倒叙
rdd.sortBy(num => num, ascending = false)

案例:

val rdd16: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4, 5, 6, 7, 8, 9), 3)
//  重新排序,默认升序
val rdd161: RDD[Int] = rdd16.sortBy(num => num)
//  重新排序,配置降序
val rdd162: RDD[Int] = rdd16.sortBy(num => num, ascending = false)
val rdd17: RDD[(Int, Int)] = sc.makeRDD(List((1, 2), (3, 4), (5, 6)))
//  先按照第1个值升序,在按第2个值排序
val rdd171: RDD[(Int, Int)] = rdd17.sortBy(num => num)

1.11 map和mapPartitions区别

在这里插入图片描述

map与mapPartitions的区别

  • 函数针对的对象不一样
    • map的函数是针对每个元素操作
    • mapPartitions的函数是针对每个分区操作
  • 函数的返回值不一样
    • map的函数是针对每个元素操作,要求返回一个新的元素,map生成的新RDD元素个数 = 原RDD元素个数
    • mapPartitions的函数是针对分区操作,要求返回新分区的迭代器,mapPartitions生成新RDD元素个数不一定=原RDD元素个数
  • 元素内存回收的时机不一样
    • map对元素操作完成之后就可以垃圾回收了
    • mapPartitions必须要等到分区数据迭代器里面数据全部处理完成之后才会统一垃圾回收,如果分区数据比较大可能出现内存溢出,此时可以用map代替。
val rdd02: RDD[Int] = rdd01.mapPartitions(a => a.map(b => b * 2))
val rdd03: RDD[Int] = rdd02.mapPartitions(a => a.map(_ * 2))

1.12 coalesce和repartition区别

  • coalesce重新分区,可以选择是否进行shuffle过程。由参数shuffle: Boolean = false/true决定。
  • repartition实际上是调用的coalesce,进行shuffle。源码如下:
def repartition(numPartitions: Int)(implicit ord: Ordering[T] = null): RDD[T] = withScope {coalesce(numPartitions, shuffle = true)
}
  • coalesce一般为缩减分区,如果扩大分区,不使用shuffle是没有意义的,repartition扩大分区执行shuffle。

2、双-Value类型

2.1 intersection()_交集

并集不去重

  • 对源RDD和参数RDD求交集后返回一个新的RDD。
  • 利用shuffle的原理进行求交集 ,需要将所有的数据落盘shuffle 效率很低
  • 不推荐使用

在这里插入图片描述

println(rdd01.intersection(rdd02)
val rdd01: RDD[Int] = sc.makeRDD(1 to 4)
val rdd02: RDD[Int] = sc.makeRDD(4 to 8)
//	取交集
//	利用shuffle的原理进行求交集  需要将所有的数据落盘shuffle 效率很低  不推荐使用
println(rdd01.intersection(rdd02).collect().toList)

2.2 union()_并集不去重

并集不去重

  • 对源RDD和参数RDD求并集后返回一个新的RDD
  • 由于不走shuffle ,效率高 。
  • 所有会使用到

在这里插入图片描述

rdd1.union(rdd2)
val rdd01: RDD[Int] = sc.makeRDD(1 to 4)
val rdd02: RDD[Int] = sc.makeRDD(4 to 8)
//	由于不走shuffle  效率高  所有会使用到
rdd1.union(rdd2).collect().foreach(println)

2.3 subtract()_差集

差集

  • 计算差的一种函数,去除两个RDD中相同元素,不同的RDD将保留下来。
  • 同样使用shuffle的原理,将两个RDD的数据写入到相同的位置,进行求差集
  • 需要走shuffle 效率低,不推荐使用
  • 在rdd01的数据中,与rdd02相差的数据(1,2,3)

在这里插入图片描述

//	计算第一个RDD与第二个RDD的差集并打印
rdd01.subtract(rdd02)
val rdd01: RDD[Int] = sc.makeRDD(1 to 4)
val rdd02: RDD[Int] = sc.makeRDD(4 to 8)
// 同样使用shuffle的原理  将两个RDD的数据写入到相同的位置 进行求差集
// 需要走shuffle  效率低  不推荐使用
//	在rdd01的数据中,与rdd02相差的数据(1,2,3)
rdd01.subtract(rdd02).collect().foreach(println)

2.4 zip()_拉链

拉链

  • 该操作可以将两个RDD中的元素,以键值对的形式进行合并。
  • 其中,键值对中的Key为第1个RDD中的元素,Value为第2个RDD中的元素。
  • 将两个RDD组合成Key/Value形式的RDD,这里默认两个RDD的partition数量以及元素数量都相同,否则会抛出异常。

在这里插入图片描述

val rdd01: RDD[Int] = sc.makeRDD(Array(1, 2, 3), 3)
val rdd02: RDD[String] = sc.makeRDD(Array("a", "b", "c"), 3)
//  List((1,a), (2,b), (3,c))
println(rdd01.zip(rdd02).collect().toList)
//  List((a,1), (b,2), (c,3))
println(rdd02.zip(rdd01).collect().toList)

反例:

val rdd02: RDD[String] = sc.makeRDD(Array("a", "b", "c"), 3)val rdd03: RDD[String] = sc.makeRDD(Array("a", "b"), 3)
//  元素个数不同,不能拉链
//  SparkException: Can only zip RDDs with same number of elements in each partition
println(rdd03.zip(rdd02).collect().toList)
val rdd04: RDD[String] = sc.makeRDD(Array("a", "b", "c"), 2)
//  分区数不同,不能拉链
//  java.lang.IllegalArgumentException: Can't zip RDDs with unequal numbers of partitions: List(2, 3)
println(rdd04.zip(rdd02).collect().toList)

3、Key—Value类型

3.1 partitionBy()_按照K重新分区

按照K重新分区

  • 将RDD[K,V]中的K按照指定Partitioner重新进行分区;
  • 如果原有的RDD和新的RDD是一致的话就不进行分区,否则会产生Shuffle过程。
  • 分区数量会改变。

在这里插入图片描述

//	使用hash计算方式重分区,并重分区后分区数量 = 2
rdd01.partitionBy(new HashPartitioner(2))
val rdd01: RDD[(Int, String)] = sc.makeRDD(Array((111, "aaa"), (222, "bbbb"), (333, "ccccc")), 3)
val rdd02: RDD[(Int, String)] = rdd01.partitionBy(new HashPartitioner(2))//	打印重分区后的分区数量
//	(0,(2,bbbb))
//	(1,(1,aaa))
//	(1,(3,ccccc))
val rdd03: RDD[(Int, (Int, String))] = rdd02.mapPartitionsWithIndex((index, datas) => {datas.map((index, _))
})
rdd03.collect().foreach(println)

3.2 groupByKey()_按照K重新分组

按照K重新分组

  • groupByKey对每个key进行操作,但只生成一个seq,并不进行聚合。
  • 该操作可以指定分区器或者分区数(默认使用HashPartitioner)。
  • 分区数量不会改变。

在这里插入图片描述

rdd001.groupByKey()
val rdd001: RDD[(String, Int)] = sc.makeRDD(List(("a", 1), ("b", 5), ("a", 5), ("b", 2)
val rdd002: RDD[(String, Iterable[Int])] = rdd001.groupByKey()
//  (a,CompactBuffer(1, 5))
//  (b,CompactBuffer(5, 2))
rdd002.collect().foreach(println)

3.3 reduceByKey()_按照K聚合V

按照K聚合V

  • 该操作可以将RDD[K,V]中的元素按照相同的K对V进行聚合。
  • 其存在多种重载形式,还可以设置新RDD的分区数。

在这里插入图片描述

rdd01.reduceByKey((v1, v2) => (v1 + v2))
val rdd01: RDD[(String, Int)] = sc.makeRDD(List(("a", 1), ("b", 5), ("a", 5), ("b", 2)))
val rdd02: RDD[(String, Int)] = rdd01.reduceByKey((v1, v2) => (v1 + v2))
//  List((a,6), (b,7))
println(rdd02.collect().toList)

3.4 aggregateByKey()_不同逻辑的归约

分区内和分区间逻辑不同的归约

在这里插入图片描述

//	zeroValue(初始值):给每一个分区中的每一种key一个初始值;
//	seqOp(分区内):函数用于在每一个分区中用初始值逐步迭代value;
//	combOp(分区间):函数用于合并每个分区中的结果。def aggregateByKey[U: ClassTag](zeroValue: U, partitioner: Partitioner)(seqOp: (U, V) => U,combOp: (U, U) => U): RDD[(K, U)] = self.withScope {}
//	分区初始值=0,分区内取最大值,分区间求和
rdd01.aggregateByKey(0)(math.max(_, _), _ + _)
val rdd01: RDD[(String, Int)] = sc.makeRDD(List(("a", 1), ("b", 5), ("a", 5), ("b", 2)))
//	取出每个分区相同key对应值的最大值,然后相加
val rdd02: RDD[(String, Int)] = rdd01.aggregateByKey(0)(math.max(_, _), _ + _)
//	List((a,6), (b,7))
println(rdd02.collect().toList)

3.5 sortByKey()_按照K进行排序

按照K进行排序

  • 在一个(K,V)的RDD上调用,K必须实现Ordered接口,返回一个按照key进行排序的(K,V)的RDD。

在这里插入图片描述

//  按照key的正序(默认正序)
rdd01.sortByKey(ascending = true)
//  按照key的倒序排列
rdd01.sortByKey(ascending = false)
val rdd01: RDD[(Int, String)] = sc.makeRDD(Array((3, "aa"), (6, "cc"), (2, "bb"), 1, "dd"))
//  按照key的正序(默认正序)
println(rdd01.sortByKey(ascending = true).collect().toList)
//  按照key的倒序排列
println(rdd01.sortByKey(ascending = false).collect().toList)

3.6 mapValues()_只对V进行操作

只对V进行操作

  • 针对于(K,V)形式的类型只对V进行操作

在这里插入图片描述

rdd01.mapValues(_ + "|||")
val rdd01: RDD[(Int, String)] = sc.makeRDD(Array((1, "a"), (1, "d"), (2, "b"), (3, "c")))
//  对Value值添加字符串|||
//  List((1,a|||), (1,d|||), (2,b|||), (3,c|||))
println(rdd01.mapValues(_ + "|||").collect().toList)

3.7 join()_等同于sql内连接

join() 等同于sql里的内连接,关联上的要,关联不上的舍弃

  • 在类型为(K,V)和(K,W)的RDD上调用,返回一个相同key对应的所有元素对在一起的(K,(V,W))的RDD。
  • 类似于SQL中的join(内联)

在这里插入图片描述

//  按key进行 内联join
rdd01.join(rdd02)
val rdd01: RDD[(Int, String)] = sc.makeRDD(Array((1, "a"), (2, "b"), (3, "c")))
val rdd02: RDD[(Int, Int)] = sc.makeRDD(Array((1, 4), (2, 5), (4, 6)))
//  按key进行 内联join
//  List((1,(a,4)), (2,(b,5)))
println(rdd01.join(rdd02).collect().toList)

3.8 cogroup()_类似于sql全连接

cogroup() 类似于sql的全连接,但是在同一个RDD中对key聚合

  • 在类型为(K,V)和(K,W)的RDD上调用,返回一个(K,(Iterable,Iterable))类型的RDD。
  • 操作两个RDD中的KV元素,每个RDD中相同key中的元素分别聚合成一个集合。
  • 取并集

在这里插入图片描述

//  cogroup 合并两个RDD,取并集
rdd01.cogroup(rdd02)
val rdd01: RDD[(Int, String)] = sc.makeRDD(Array((1, "a"), (2, "b"), (3, "c")))
val rdd02: RDD[(Int, Int)] = sc.makeRDD(Array((1, 4), (2, 5), (4, 6)))
//  cogroup 两个RDD并打印
//  List((1,(CompactBuffer(a),CompactBuffer(4))), (2,(CompactBuffer(b),CompactBuffer(5)))
//  (3,(CompactBuffer(c),CompactBuffer())), (4,(CompactBuffer(),CompactBuffer(6))))
println(rdd01.cogroup(rdd02).collect().toList)

cogroup后结果处理

val rdd01: RDD[(Int, Int)] = sc.makeRDD(Array((1, 4), (2, 1), (3, 5)))
val rdd02: RDD[(Int, Int)] = sc.makeRDD(Array((1, 4), (2, 5), (4, 6)))
//	cogroup后类型为Iterable,key调用其sum进行值求和(相同的key)
val value1: RDD[(Int, (Iterable[Int], Iterable[Int]))] = rdd01.cogroup(rdd02)
val value: RDD[(Int, (Int, Int))] = value1.mapValues(a => {(a._1.sum, a._2.sum)
})

3.9 自定义分区器

要实现自定义分区器,需要继承org.apache.spark.Partitioner类,并实现下面三个方法。

  1. numPartitions: Int:返回创建出来的分区数。
  2. getPartition(key: Any): Int:返回给定键的分区编号(0到numPartitions-1)。
  3. equals():Java 判断相等性的标准方法。这个方法的实现非常重要,Spark需要用这个方法来检查你的分区器对象是否和其他分区器实例相同,这样Spark才可以判断两个RDD的分区方式是否相同。
val rdd01: RDD[(Int, String)] = sc.makeRDD(Array((1, "a"), (2, "b"), (3, "c")))
val rdd02: RDD[(Int, String)] = rdd01.partitionBy(new MyParTition(2))
println(rdd02.collect().toList)
class MyParTition(num: Int) extends Partitioner {//  设置分区数override def numPartitions: Int = num//  具体分区逻辑override def getPartition(key: Any): Int = {//  采用模式匹配。依据不同的类型,采用不同的处理逻辑//  字符串:放入0号分区。整数:取模分区个数key match {case s: String => 0case i: Int => i % numPartitionscase _ => 0}}
}

3.10 reduceByKey和groupByKey区别

  • reduceByKey:按照key进行聚合,在shuffle之前有combine(预聚合)操作,返回结果是RDD[K,V]。
  • groupByKey:按照key进行分组,直接进行shuffle。
  • 开发指导:在不影响业务逻辑的前提下,优先选用reduceByKey。求和操作不影响业务逻辑,求平均值影响业务逻辑,后续会学习功能更加强大的归约算子,能够在预聚合的情况下实现求平均值。

三、行动算子(Action)

行动算子是触发了整个作业的执行。因为转换算子都是懒加载,并不会立即执行。

1、collect()_以数组的形式返回数据集

以数组的形式返回数据集

  • 在驱动程序中,以数组Array的形式返回数据集的所有元素。

在这里插入图片描述

rdd02.collect().toList

2、count()_返回RDD中元素个数

返回RDD中元素个数

在这里插入图片描述

println(rdd01.count())

3、first()_返回RDD中的第一个元素

返回RDD中的第一个元素

在这里插入图片描述

println(rdd01.first())

4、take()_返回由RDD前n个元素组成的数组

返回由RDD前n个元素组成的数组

在这里插入图片描述

//	返回由前3个元素组成的数组
rdd01.take(3)
val number: Array[(Int, String)] = rdd01.take(3)

5、takeOrdered()_返回排序后前n个元素

返回该RDD排序后前n个元素组成的数组

在这里插入图片描述

// returns Array(2)
sc.parallelize(Seq(10, 4, 2, 12, 3)).takeOrdered(1)// returns Array(2, 3)
sc.parallelize(Seq(2, 3, 4, 5, 6)).takeOrdered(2)//  List(1, 2)
val rdd02: Array[Int] = sc.makeRDD(List(1, 3, 2, 4)).takeOrdered(2)
println(rdd02.toList)

6、countByKey()_统计每种key的个数

统计每种key的个数

在这里插入图片描述

 rdd01.countByKey()
val rdd01: RDD[(Int, String)] = sc.makeRDD(List((1, "a"), (1, "a"), (1, "a"), (2, "b"), (3, "c"), (3, "c")))
val rdd02: collection.Map[Int, Long] = rdd01.countByKey()
//  Map(1 -> 3, 2 -> 1, 3 -> 2)
println(rdd02)

7、saveAsTextFile(path)_保存成Text文件

保存成Text文件

  • 将数据集的元素以textfile的形式保存到HDFS文件系统或者其他支持的文件系统,对于每个元素,Spark将会调用toString方法,将它装换为文件中的文本

在这里插入图片描述

val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4), 2)
//	保存到本地Text文件
rdd.saveAsTextFile("output01")

8、saveAsSequenceFile(path)_保存成Sequencefile文件

保存成Sequencefile文件

  • 将数据集中的元素以Hadoop Sequencefile的格式保存到指定的目录下,可以使HDFS或者其他Hadoop支持的文件系统。
  • 只有kv类型RDD有该操作,单值的没有
val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4), 2)
//	保存成Sequencefile文件
rdd.saveAsObjectFile("output02")

9、saveAsObjectFile(path)_序列化成对象保存到文件

序列化成对象保存到文件

  • 用于将RDD中的元素序列化成对象,存储到文件中。
val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4), 2)
//	序列化成对象保存到文件
rdd.map((_, 1)).saveAsObjectFile("output03")

10、foreach()_遍历RDD中每一个元素

遍历RDD中每一个元素

在这里插入图片描述

//  收集后打印
rdd.collect().foreach(println)
//  分布式打印
rdd.foreach(println)

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.rhkb.cn/news/118235.html

如若内容造成侵权/违法违规/事实不符,请联系长河编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

卡特兰数和算法

在组合数学中,卡特兰数是一系列自然数,出现在各种组合计数问题中,通常涉及递归定义的对象。它们以比利时数学家尤金查尔斯卡特兰(Eugne Charles Catalan)的名字命名。 卡特兰数序列是1, 1, 2, 5, 14, 42......&#xf…

java.sql.SQLException: com.mysql.cj.jdbc.Driver

这篇文章分享一下Springboot整合Elasticsearch时遇到的一个问题,项目正常启动,但是查询数据库的时候发生了一个异常java.sql.SQLException: com.mysql.cj.jdbc.Driver java.sql.SQLException: com.mysql.cj.jdbc.Driverat com.alibaba.druid.util.JdbcU…

【德哥说库系列】-ASM管理Oracle 19C单实例部署

📢📢📢📣📣📣 哈喽!大家好,我是【IT邦德】,江湖人称jeames007,10余年DBA及大数据工作经验 一位上进心十足的【大数据领域博主】!😜&am…

微软 Turing Bletchley v3视觉语言模型更新:必应搜索图片更精准

据微软新闻稿透露,在推出第三代Turing Bletchley视觉语言模型后,微软计划逐步将其整合到Bing等相关产品中,以提供更出色的图像搜索体验。这款模型最初于2021年11月面世,并在2022年秋季开始邀请用户测试。 凭借用户的反馈和建议&am…

mapboxGL3新特性介绍

概述 8月7日,mapboxGL发布了3版本的更新,本文带大家一起来看看mapboxGL3有哪些新的特性。 新特新 如上图所示,是mapboxGL官网关于新版的介绍,大致翻译如下: 增强了web渲染的质量、便捷程度以及开发人员体验&#xff…

【云计算•云原生】5.云原生之初识DevOps

文章目录 1.DevOps背景2.DevOps概念3.DevOps工具链 1.DevOps背景 软件开发必须包含两个团队:开发团队和运维团队 开发团队负责开发项目,系统迭代更新运维团队负责项目测试以及部署上线,维持系统稳定运行 一个软件周期中是由这两个团队相互…

buildroot修改内核防止清理重新加载办法

当你使用 Buildroot 构建 Linux 内核时,如果对内核文件进行了手动修改,重新执行 Buildroot 的构建过程将会覆盖你所做的修改。这是因为 Buildroot会根据配置重新下载、提取和编译内核。 为了避免在重新构建时覆盖你的修改,可以采取以下两种方…

数据可视化与数字孪生:理解两者的区别

在数字化时代,数据技术正在引领创新,其中数据可视化和数字孪生是两个备受关注的概念。尽管它们都涉及数据的应用,但在本质和应用方面存在显著区别。本文带大探讨数据可视化与数字孪生的差异。 概念 数据可视化: 数据可视化是将复…

Windows下将nginx等可执行文件添加为服务

Windows下将nginx等可执行文件添加为服务 为什么将可执行文件添加为服务?将可执行文件添加为服务的步骤步骤 1:下载和安装 Nginx步骤 2:添加为服务方法一:使用 Windows 自带的 sc 命令方法二:使用 NSSM(Non…

Vue实战【调整Vue-element-admin中的菜单栏,并添加顶部模块菜单栏】

目录 🌟前言🌟小伙伴们先看🌟实现思路🌟具体代码🌟最后 🌟前言 因为最近在整合公司的项目,需要把所有系统里的功能集成到一个项目里,这样就导致菜单栏目录会特别的多,不…

【MySQL学习笔记】(七)内置函数

内置函数 日期函数示例案例-1案例-2 字符串函数示例 数学函数其他函数 日期函数 示例 获得当前年月日 mysql> select current_date(); ---------------- | current_date() | ---------------- | 2023-09-03 | ---------------- 1 row in set (0.00 sec)获得当前时分秒…

ARM 汇编基础知识

1.为什么学习汇编? 我们在进行嵌入式 Linux 开发的时候是绝对要掌握基本的 ARM 汇编,因为 Cortex-A 芯片一 上电 SP 指针还没初始化, C 环境还没准备好,所以肯定不能运行 C 代码,必须先用汇编语言设置好 C 环境…

HarmonyOS应用开发者高级认证练习题

系列文章目录 HarmonyOS应用开发者基础认证练习题 HarmonyOS应用开发者高级认证练习题 文章目录 系列文章目录前言一、判断二、单选三、多选 前言 本文所有内容来源于个人进行HarmonyOS应用开发者系列认证的学习过程中所做过的练习题,所有答案均是个人作答&#x…

手撕 视觉slam14讲 ch7 / pose_estimation_3d2d.cpp (1)

首先理清我们需要实现什么功能,怎么实现,提供一份整体逻辑:包括主函数和功能函数 主函数逻辑: 1. 读图,两张rgb(cv::imread) 2. 找到两张rgb图中的特征点匹配对 2.1定义所需要的参数:keypoints…

手机怎么剪视频?分享一些剪辑工具和注意事项

视频剪辑是一种将多个视频片段进行剪切、合并和编辑的技术,它可以帮助我们制作出精彩的视频作品。如今,随着智能手机的普及,我们可以随时随地使用手机进行视频剪辑。本文将为大家介绍一些手机剪辑工具和注意事项,帮助大家更好地进…

MATLAB实现AHP层次分析法——以情人节选取礼物为例

问题背景: 情人节来临之际,广大直男(女)同胞在给异性朋友选购礼物时会遇到难题——什么才是礼物好坏最重要的标准?基于层次分析法AHP进行计算,得出最高权重的指标,给出各位朋友选购礼物的一种思…

Vue框架--Vue中的数据绑定

Vue中有两种数据绑定的方式 1.单向数据绑定(v-band):数据只能够从data流向页面 2.双向数据绑定(v-model):数据不仅仅能够从data流向页面,也可以从页面流向data。 备注: 1.双向绑定一般都应用在表单类元素上。(如:input、select等有value属性值的标签上) 2.…

[ZenTao]源码阅读:自定义任务类型

1、module/custom/control.php 2、module/custom/model.php

C#-单例模式

文章目录 单例模式的概述为什么会有单例模式如何创建单例模式1、首先要保证,该对象 有且仅有一个2、其次,需要让外部能够获取到这个对象 示例通过 属性 获取单例 单例模式的概述 总结来说: 单例 就是只有 一个实例对象。 模式 说的是设计模式…

多线程的五种“打开”方式

1 概念 1.1 线程是什么?? 线程(Thread)是计算机科学中的一个基本概念,它是进程(Process)中的一个执行单元,负责执行程序的指令序列。线程是操作系统能够进行调度和执行的最小单位。…