spark转换算子12中API的操作

最新推荐文章于 2026-06-22 15:44:50 发布

原创最新推荐文章于 2026-06-22 15:44:50 发布 · 160 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#spark

本文详细介绍了Spark中常见的数据操作，包括使用map对数据进行映射处理，mapPartitions与mapPartitionsWithIndex对分区数据进行操作，flatMap实现数据扁平化，glom将分区数据转换为数组，groupBy进行数据分组，filter筛选数据，sample进行数据抽样，distinct去除重复项，coalesce与repartition调整分区数量，以及sortBy对数据进行排序。这些操作对于理解和使用Spark进行大数据处理至关重要。

value类型

map

 //设置APP名称
    val conf: SparkConf = new SparkConf().setAppName("SparkCoreTest").setMaster("local[*]")
    //获取配置信息
    val sc = new SparkContext(conf)

    val rdd: RDD[Int] = sc.makeRDD(1 to 4)
    //通过映射对每个值乘3
    val rdd1: RDD[Int] = rdd.map(_ * 3)
    rdd1.collect().foreach(println)

    sc.stop()

mappartitions

val rdd: RDD[Int] = sc.makeRDD( 1 to 50,2)
    val rdd2: RDD[Int] = rdd.mapPartitions(_.map( _ * 2 ))
    rdd2.saveAsTextFile("out")

mapPartitionsWithIndex

 val rdd: RDD[Int] = sc.makeRDD(1 to 10 , 2)
    //对每个分区的数据在前加分区号  方便辨认
    val rdd1: RDD[(Int, Int)] = rdd.mapPartitionsWithIndex((index,items) =>items.map((index,_)))
    rdd1.collect().foreach(println)

flatmap 扁平化

 val rdd: RDD[String] = sc.textFile("D://DATAS//data.txt",2)
    //将数据先进行已空格划分  然后在进行扁平化 
//    val rdd1: RDD[Array[String]] = rdd.map(_.split(" "))
//    val rdd2: RDD[String] = rdd1.flatMap(data => data)
    
    //以上简化为
    val rdd2: RDD[String] = rdd.flatMap(_.split(" "))
    rdd2.collect().foreach(println)

glom

val rdd: RDD[Int] = sc.makeRDD(1 to 20,3)
    //将分区的数据转成数组
    val rdd1: RDD[Array[Int]] = rdd.glom()
    //选出每个数组的最大值
     val rdd2: RDD[Int] = rdd1.map(_.max)
    println(rdd2.collect().sum)

groupby

	val rdd: RDD[String] = sc.textFile("input/1.txt",2)
//将数据扁平化
    val rdd1: RDD[String] = rdd.flatMap(_.split(" "))
    //去每个数据的头部进行分区
    val rdd2: RDD[(String, Iterable[String])] = rdd1.groupBy(_.substring(0,1))
    //计算每个分区的数据数
    val rdd3: RDD[(String, Int)] = rdd2.map(data => {
      val key: String = data._1
      val value: Int = data._2.size
      (key, value)
    })
    rdd3.collect().foreach(println)

filter

val rdd: RDD[String] = sc.textFile("input/1.txt")
//筛选出包含"he"的数据
    val rdd2: RDD[String] = rdd.flatMap(_.split(" ")).filter(_.contains("he"))
    rdd2.collect().foreach(println)

sample


    val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4,5,6,7,8,9))
    //不放回   伯努利算法  第一个表示是都放回，第二个是表示发生的概率  第三个是种子
   			 //无种子
//    val rdd2: RDD[Int] = rdd.sample(false,0.5)
//    rdd2.collect().foreach(println)
			//设置种子
//    val rdd2: RDD[Int] = rdd.sample(false,0.5,10)
//    rdd2.collect().foreach(println)

    //放回  泊松算法
//      val rdd1: RDD[Int] = rdd.sample(true,0.5)
//      val rdd1: RDD[Int] = rdd.sample(true,3)
      val rdd1: RDD[Int] = rdd.sample(true,3,5)
    rdd1.collect().foreach(println)

distinct

 val rdd: RDD[Int] = sc.makeRDD(List(1,3,4,3,6,7,5,4,2,4,5,6,7,3,3,4))
    rdd.distinct().collect().foreach(println)

    // 对RDD采用多个Task去重，提高并发度
//    rdd.distinct(2).foreach(println)

coalesce 合并分区

 val rdd: RDD[Int] = sc.makeRDD(Array(1, 2, 3, 4, 5, 6), 3)
    //使用shuffle
    val rdd1: RDD[Int] = rdd.coalesce(2,true)
    //不走shuffle
//    val rdd1: RDD[Int] = rdd.coalesce(2)
    rdd1.mapPartitionsWithIndex((index,iteams)=>iteams.map((index,_))).collect().foreach(println)

repartition 重新分区

 val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4,5,6,7,8),2)
         //repartition   默认执行shuffle
    val rdd1: RDD[(Int, Int)] = rdd.repartition(4) .mapPartitionsWithIndex((index,iteams)=>iteams.map((index,_)))
    rdd1.collect().foreach(println)

sortBy

val rdd: RDD[Int] = sc.makeRDD(List(2, 1, 3, 4, 6, 5))
//默认是升序即true   降序手动设置false
//    rdd.sortBy(data => data).collect().foreach(println)
    rdd.sortBy(data => data,false).collect().foreach(println)